这道题卡住了，求大家帮忙看看，或者提供下思路,该怎么处理_C++,C语言_ThinkSAAS
这道题卡住了，求大家帮忙看看，或者提供下思路,该怎么处理
这道题卡住了，求大家帮忙看看，或者提供下思路,该怎么处理
内容来源： 网络
这道题卡住了，求大家帮忙看看，或者提供下思路有一天，Lolita上街买菜，在她要买鸡蛋的时候，忽然盯着几个篮子发呆。她在想，如果把手中的鸡蛋都放到这几个篮子里，有多少种放法呢？她想了很久，但想不出来应该怎么算，你们能帮帮她吗？输入：多组数据，每一组是一行，一行有两个数e,b，e是鸡蛋数目(1&=e&=1000)，b是篮子数目(1&=b&=100)。输出：对每一组数据算出总放法数目并输出，要单独占一行。题目数据保证最后计算结果小于1e19样例输入：8 18 26 37 3样例输出：1578提示：6 3的话，可以是0+0+60+1+50+2+40+3+31+1+41+2+32+2+2共7种方法C/C++ code #include &iostream&
#include &set&
int count = 0;
void putegg(int egg, int basket);
void main()
putegg(egg, basket);
cout && count &&
void putegg(int egg, int basket)
if (egg & 0 || basket & 0)
else if (egg == 0 && basket == 0)
for (int i = 0; i &= ++i)//用递归遍历所有出现的可能
//set&int&
int tegg = egg -
int tbasket = basket - 1;
//rec.insert(tegg);
putegg(tegg, tbasket);
------解决方案--------------------由代码可知是动态规划题目探讨这个看不懂C/C++ code#include&stdio.h&_int64 dp[101][1001];void init();int main(){ int n, init();
while(scanf("%d %d", &n, &m)!=EOF) { ……
------解决方案--------------------for (int i = egg&limit?limit: i &= (egg-i)/(basket-1); --i)让i从本次递归里允许的最大值开始，直到等于下一次递归所能允许的最小限额为止进行循环。如果剩下的蛋在剩下的篮子里平分之后都还比i大，那显然是没法保证后面的递归符合不重复的原则了。因为要保证不重复就得保证后面的篮子里不会有比前面的篮子更多的鸡蛋。
------解决方案--------------------好像那个循环终止条件有问题......整数除法会丢掉余数，特定的数字下可能导致i过小。
------解决方案--------------------for (int i = egg&limit?limit: i &= (egg-i+basket-2)/(basket-1); --i)
------解决方案--------------------简化一下：C/C++ code
for (int i = egg&limit?limit: i*basket &= --i)
------解决方案--------------------在网上搜索动态规划，DP之类的，能看到很多资料。动态规划稍微的学学很容易，应用也很简单。用来计算各种组合爆炸的问题超级强大。超出数据范围了就只有用自己写的大数方式了，到博客区一搜一大堆。
PHP开发框架
开发工具/编程工具
服务器环境
ThinkSAAS商业授权：
ThinkSAAS为用户提供有偿个性定制开发服务
ThinkSAAS将为商业授权用户提供二次开发指导和技术支持
让ThinkSAAS更好，把建议拿来。
开发客服微信下面这些题目都是我之前准备笔试面试过程中积累的，大部分都是知名公司的笔试题，C++基础薄弱的很容易栽进去。我从中选了10道简单的题，C++初学者可以进来挑战下，C++大牛也可以作为娱乐玩下（比如下面的第6题）。为了便于大家思考，将题目与答案分开，不过无论题目本身如何，我觉得后面的解析过程更值得学习，因为涉及很多我们学习C++过程中必知必会的小知识点 。
第一部分：题目
如下函数，在32 bit系统foo(2^31-3)的值是：（）
int foo(int x)
return x&-x;
A：0 B: 1 C: 2 D: 4
运算符优先级
unsigned char i=0x80;
printf("0x%x\n", ~i&&3+1);
输出什么？
静态对象是否调用构造函数？
#include &iostream&
using namespace
A() { cout && "A's Constructor Called " &&
B() { cout && "B's Constructor Called " && }
int main()
#include &stdio.h&
char x[2];
int main()
a.x[0] = 10;
a.x[1] = 1;
printf("%d",a.i);
下面代码会报错吗？为什么？
void print() {
cout && "A\n";
A *pa = 0;
pa-&print();
下面代码的输出是什么？（非常考基础水平的一道题）
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char **cp[] = { c + 3 , c + 2 , c + 1 , c};
char ***cpp =
int main(void)
printf("%s",**++cpp);
printf("%s",*--*++cpp+3);
printf("%s",*cpp[-2]+3);
printf("%s\n",cpp[-1][-1]+1);
#include &stdio.h&
struct data
unsigned short
int main(void)
mData.b = 0x0102;
char *pData = (char *)&mD
printf("%d %d", sizeof(pData), (int)(*(pData + 4)));
改变string变量的值？
#include &iostream&
#include &string&
using namespace
void chg_str(string str) {
str = "ichgit";
int main() {
string s = "sarrr";
chg_str(s);
printf("%s\n", s.c_str());
cout && s &&
静态变量的输出
#include &stdio.h&
int sum(int a) {
int c = 0;
static int b = 3; // 只执行一次
return (a + b + c);
int main() {
int a = 2;
for(i = 0; i & 5; ++i) {
printf("%d\n", sum(a));
返回值加const修饰的必要性
你觉得下面两种写法有区别吗？
int GetInt(void)
const int GetInt(void)
如果是下面的呢？其中A 为用户自定义的数据类型。
A GetA(void)
const A GetA(void)
第二部分：答案详细解析
如下函数，在32 bit系统foo(2^31-3)的值是：
int foo(int x)
return x&-x;
A：0 B: 1 C: 2 D: 4&
解释：我只想说注意运算符优先级，注意^是异或而不是幂次方。
运算符优先级
unsigned char i=0x80;
printf("0x%x\n", ~i&&3+1);输出什么？
输出：0xfffffff7（提示：+的优先级优于&&）
如果将unsigned去掉，则输出0x7。
静态对象是否调用构造函数？
#include &iostream&
using namespace
A() { cout && "A's Constructor Called " &&
B() { cout && "B's Constructor Called " && }
int main()
B's Constructor Called
解释：上面的程序只是调用了B的构造函数，没有调用A的构造函数。因为静态成员变量只是在类中声明，没有定义。静态成员变量必须在类外使用作用域标识符显式定义。
如果我们没有显式定义静态成员变量a，就试图访问它，编译会出错，比如下面的程序编译出错：
#include &iostream&
using namespace
A() { cout && "A's constructor called " &&
B() { cout && "B's constructor called " && }
static A getA() { return }
int main()
A a = b.getA();
Compiler Error: undefined reference to `B::a
如果我们加上a的定义，那么上面的程序可以正常运行，
注意：如果A是个空类，没有数据成员x，则就算B中的a未定义也还是能运行成功的，即可以访问A。
#include &iostream&
using namespace
A() { cout && "A's constructor called " &&
B() { cout && "B's constructor called " && }
static A getA() { return }
// definition of a
int main()
B b1, b2, b3;
A a = b1.getA();
A's constructor called
B's constructor called
B's constructor called
B's constructor called
上面的程序调用B的构造函数3次，但是只调用A的构造函数一次，因为静态成员变量被所有对象共享，这也是它被称为类变量的原因。同时，静态成员变量也可以通过类名直接访问，比如下面的程序没有通过任何类对象访问，只是通过类访问a。
int main()
// static member 'a' is accessed without any object of B
A a = B::getA();
A's constructor called
#include &stdio.h&
char x[2];
int main()
a.x[0] = 10;
a.x[1] = 1;
printf("%d",a.i);
输出：266，自己画个内存结构图就知道了，注意union的存放顺序是所有成员都从低地址开始存放。Union的大小为其内部所有变量的最大值，并且按照类型最大值的整数倍进行内存对齐。
下面代码会报错吗？为什么？
void print() {
cout && "A\n";
A *pa = 0;
pa-&print();
答案：正常输出。上面的代码可以这样理解（这非常重要）：
void print(A *this) {
cout && "A\n";
A *pa = 0;
print_A();
也就是：并不是类没有初始化就不能调用类的成员函数，如果成员函数只是简单的打印个东西，没有调用类成员啥的就不会报段错误。
下面代码的输出是什么？（非常考基础水平的一道题）
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char **cp[] = { c + 3 , c + 2 , c + 1 , c};
char ***cpp =
int main(void)
printf("%s",**++cpp);
printf("%s",*--*++cpp+3);
printf("%s",*cpp[-2]+3);
printf("%s\n",cpp[-1][-1]+1);
c是一个指针数组，每个数组元素都是char*类型的指针，值分别是那些字符串(的首地址)：
c[0] = "ENTER"
c[1] = "NEW"
c[2] = "POINT"
c[3] = "FIRST"
而[]和*是本质一样的运算，即c[i]=*(c+i)。
c和c+i都是char *[]类型，它可以退化成char **类型，再看cp，它正好是一个char **的数组，来看它的值：
cp[0] = c + 3
cp[1] = c + 2
cp[2] = c + 1
引用后就有：cp[0][0]=*(c + 3)=c[3]="FIRST"，以此类推。
cp是char **[]类型，它可以退化成char ***类型，看最后的cpp，它正是char ***类型，它是一个指针变量，和上面两个不同，上面两个是数组。
这样分析过后，下面的解析就一目了然了：
printf("%s",**++cpp);
++cpp的值是cp+1，引用一次后是cp[1]再引用是*cp[1]=c[2]="POINT"，第一句的输出
printf("%s",*--*++cpp+3);
再++cpp的值是cp+2，引用一次是cp[2]=c+1，再对这进行--，减后是c再引用是c[0]="ENTER"再+3，字符串指针指到"ER"，输出是"ER"
printf("%s",*cpp[-2]+3);
这时cpp的值是cp+2，cpp[-2]=*(cpp-2)=*(cp+2-2)=cp[0]=c+3，再引用是c[3]="FIRST",+3 字符串指针指到"ST"，输出是"ST"
printf("%s\n",cpp[-1][-1]+1);
cpp还是cp+2，cpp[-1]=*(cpp-1)=*(cp+2-1)=cp[1]=c+2，再[-1]得*(c+2-1)=c[1]="NEW",+1字符串指针指到"EW"，输出是"EW"。
#include &stdio.h&
struct data
unsigned short
int main(void)
mData.b = 0x0102;
char *pData = (char *)&mD
printf("%d %d", sizeof(pData), (int)(*(pData + 4)));
输出：4 2&
说明：一般变量都是从高到低分配内存地址，但对于结构体来说，结构体的成员在内存中顺序存放，所占内存地址依次增高，第一个成员处于低地址处，最后一个成员处于最高地址处，但结构体成员的内存分配不一定是连续的，编译器会对其成员变量依据前面介绍的 &对齐&原则进行处理。
补充知识点：
除了栈以外，堆、只读数据区、全局变量地址增长方向都是从低到高的。
改变string变量的值？
#include &iostream&
#include &string&
using namespace
void chg_str(string str) {
str = "ichgit";
int main() {
string s = "sarrr";
chg_str(s);
printf("%s\n", s.c_str());
cout && s &&
输出：仍为&sarrr&。
解释：string是传值参数，不能修改其值。要想改变string变量的值，可以改为传地址方式：
#include &iostream&
#include &string&
using namespace
void chg_str(string *str) {
*str = "ichgit";
int main() {
string s = "sarrr";
chg_str(&s);
printf("%s\n", s.c_str());
cout && s &&
静态变量的输出
#include &stdio.h&
int sum(int a) {
int c = 0;
static int b = 3; // 只执行一次
return (a + b + c);
int main() {
int a = 2;
for(i = 0; i & 5; ++i) {
printf("%d\n", sum(a));
输出：8 10 12 14 16
解释：存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化，此后该初始化不再执行，相当于一次执行后就作废，静态局部变量保存了前次被调用后留下的值。
返回值加const修饰的必要性
你觉得下面两种写法有区别吗？
int GetInt(void)
const int GetInt(void)
如果是下面的呢？其中A 为用户自定义的数据类型。
A GetA(void)
const A GetA(void)
答案：没有任何区别。
解释：如果函数返回值采用&值传递方式&，由于函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。所以，对于值传递来说，加const没有太多意义。
不要把函数int GetInt(void) 写成const int GetInt(void)。
不要把函数A GetA(void) 写成const A GetA(void)。
在编程中要尽可能多的使用const（比如函数参数采用const&修饰），这样可以获得编译器的帮助，以便写出健壮性的代码。
阅读(...) 评论()}