9.22-动态规划 //石子合并//花生米

1.石子合并

描述：在一个圆形操场的四周摆放着n堆石子(n<= 100)，现要将石子有次序地合并成一堆。规定每次只能选取相邻的两堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。编一程序，读入石子堆数n及每堆的石子数(<=20)。选择一种合并石子的方案,使得做n－1次合并,得分的总和最小；比如有4堆石子：4 4 5 9 则最佳合并方案如下：
4 4 5 9 score: 0
8 5 9 score: 8
13 9 score: 8 + 13 = 21
22 score: 8 + 13 + 22 = 43

输入：可能有多组测试数据。 当输入n=0时结束! 第一行为石子堆数n(1<=n<=100)；第二行为n堆的石子每堆的石子数,每两个数之间用一个空格分隔。

输出：合并的最小得分，每个结果一行。

输入样例：

4 4 4 5 9 0

输出样例：

43

#include<iostream>
#include<math.h>
#define MAX 100000
using namespace std;

int stone[100];
int n;
int l[100][100];

int search();
int num(int x, int y);

int main(){
	while(cin >> n && n){
		for(int i = 0; i < n; i++){
		    cin >> stone[i];
		}
		if(n == 1){
		    cout << '0' << endl;
		}
		else{
		    cout << search() << endl;
		}
	}
}

int search(){
	int i, j, k, len;
	int minnum = MAX;

	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++){
			if(i == j){
			    l[i][j] = 0;
			}
			else{
			    l[i][j] = MAX;
			}
		}
	}

	for(len = 1; len < n; len++){
		for(i = 0, j = (i+len)%n; i < n; i++, j = (j+1)%n){
			for(k = 0; k < len; k++){
				l[i][j] = min(l[i][j], l[i][(i+k)%n] + l[(i+k+1)%n][j] + num(i, j));
				if(len == n-1){
				    minnum = min(minnum, l[i][j]);
				}
			}
		}
	}

	return minnum;
}

int num(int x, int y){
	int i, ans;
	ans = 0;

	if(x < y){
		for(i = x; i <= y; i++){
			ans += stone[i];
		}
	}
	else{
		for(i = x; i < n; i++){
            ans += stone[i];
		}
		for(i = 0; i <= y; i++){
		    ans += stone[i];
		}
	}

	return ans;
}

 

2.花生米（二）

描述：五一长假第二天，Tom和Jerry在仓库散步的时候又发现了一堆花生米（这个仓库还真奇怪）。这次Tom制定分花生米规则如下：
       1、Tom和Jerry轮流从堆中取出k粒花生米吃掉，k可以是1，5，10中的任意一个数字；
       2、为显示规则的公平性，Jerry可以选择先取或者后取。
Jerry当然还是希望最后一粒花生米被Tom吃掉。请计算，Jerry为了达到目的应该先取还是后取。

输入：本题有多个测例，每个测例的输入是一个整数n，n大于零小于等于1000，代表花生米的数量。
n等于0表示输入结束，不需要处理。

输出：每个测例在单独的一行内输出一个整数：Jerry先取输出1；Tom先取输出0。

输入样例：

1
2
3
4
0

输出样例：

0
1
0
1

#include<iostream>
using namespace std;

int main(){
    int n;
	int ans[1010];
	
	for(int i = 1; i <= 10; i++){
		if(i%2 == 0){
		    ans[i] = 1;
		}
		else{
		    ans[i] = 0;
		}
	}
	for(int i = 11; i <= 1000; i++){
		if(ans[i-1] && ans[i-5] && ans[i-10]){
		    ans[i] = 0;
		}
		else{
		    ans[i] = 1;
		}
	}

	while(cin >> n && n){
	    cout << ans[n] << endl;
	}

	return 0;
}

 

3.花生米（三）

描述：五一长假第三天，Tom和Jerry在仓库散步的时候又发现了一堆花生米（仓库，又见仓库……）。这次Tom制定分花生米规则如下：
1、Tom和Jerry轮流从堆中取出k粒花生米吃掉；
2、第一次取花生米的人只能取一粒，以后取花生米的数量不能超过前一个人取花生米数量的两倍；
3、为显示规则的公平性，Jerry可以选择先取或者后取。
Jerry当然还是希望最后一粒花生米被Tom吃掉。请计算，Jerry为了达到目的应该先取还是后取。

输入：本题有多个测例，每个测例的输入是一个整数n，n大于零小于等于1000，代表花生米的数量。
n等于0表示输入结束，不需要处理。

输出：每个测例在单独的一行内输出一个整数：Jerry先取输出1；Tom先取输出0。

输入样例：

1
2
3
4
5
0

输出样例：

0
1
0
0
1

#include <iostream>

using namespace std;

int status[1010][1010];     //status[i][j]表示剩余i粒花生米，最多取j粒  【数组太大放main函数里会溢出】 
void Search(int n)
{
    for(int i = 2; i <= n; i ++)            //剩余i粒花生米
    {
        for(int j = i-1; j <= n; j++)       //最多取j粒，j>= i-1，那么只需要先取i-1，即可赢
            status[i][j] = 1;
        for(int j = 1; j < i-1; j++)       //最多取j粒，j<i-1
        {
            int flag = 0;
            for(int k = 1; k <= j; k++)     //如果取k粒
            {
                //剩余i-k粒花生米，最多取2*k粒
                //任一转移状态为0，Jerry都可以在该状态时
                //由原来的取法变为取2*k个，那么就会赢
                if(status[i-k][2*k] == 0)
                {
                    flag = 1;
                    break;
                }
            }
            status[i][j] = flag;
        }
    }
}

int main()
{

    int n;
    while(cin >> n && n)
    {
        if(n == 1)                      //一粒花生米，后取
        {
            cout << 0 << endl;
            continue;
        }
        Search(n);
        cout << status[n][1] << endl;   //n粒，最多取1粒
    }
}

 

4.花生米（四）

描述：五一长假第四天，Tom逛了N个bbs，做了N^2个脑筋急转弯题，终于发现了每次吃完花生米嘴里都是苦味的原因：自己总会吃到最后一粒花生米。
五一长假第五天，Tom和Jerry在仓库散步的时候发现了n堆花生米（这是什么仓库啊？！）。这次Tom制定分花生米规则如下：
1、首先选出最苦的一粒花生米，放到一个瓶子里；
2、Tom和Jerry轮流从任意一堆花生米中取出任意粒吃掉；
3、如果Tom吃到最后一粒花生米（瓶子里的花生米除外），Jerry必须吃掉瓶子里的花生米；如果Jerry吃到最后一粒花生米（瓶子里的花生米除外），Tom自愿吃掉瓶子里的花生米；
 4、为显示规则的公平性，Jerry可以选择先取或者后取。
Jerry当然希望瓶子里的花生米被Tom吃掉。请计算，Jerry为了达到目的应该先取还是后取。

输入：本题有多个测例。
每个测例的输入第一行是一个整数n，n大于零小于等于10，代表花生米的堆数（取出最苦花生米后）；接下来n行每行一个不超过100的正整数，分别代表一堆花生米的粒数（取出最苦花生米后）。
n等于0表示输入结束，不需要处理。

输出：每个测例在单独的一行内输出一个整数：Jerry先取输出1；Tom先取输出0。

输入样例：

2
1
1
2
1
100
0

输出样例：

0
1

http://www.cnblogs.com/tanky_woo/archive/2010/08/20/1804464.html

火柴问题

#include <iostream>
using namespace std;
int n;
int a[100];
int main()
{
	cin>>n;
	while(n){
		for(int i=0;i<n;i++){
			cin>>a[i];
		}
		int sum=0;
		for(int i=0;i<n;i++){
			sum^=a[i];
		}
		if(n%2){
			if(sum){
			    cout<<0<<endl;
			}
			else{
			    cout<<1<<endl;
			}
		}
		else{
			if(sum){
			    cout<<1<<endl;
			}
			else{
			    cout<<0<<endl;
			}
		}
		cin>>n;
	}
	return 0;
}

 

5.花生米（五）

描述：五一长假第六天，Tom在QQ上遇到了Kitty。呵呵，Kitty，在离散数学课上认识的PPMM……等等！Tom恍然大悟：自己这一生除了看帖不回之外最大的错误就是离散数学没学好！
五一长假第七天，Tom和Jerry在仓库散步的时候发现了一堆花生米（仓库，呵呵，仓库…）。这次Tom制定分花生米规则如下：
1、首先选出最苦的一粒花生米，放到一个瓶子里；
2、把剩下的花生米做成花生酱，Tom和Jerry轮流取一些花生酱吃掉；
3、第一个取的人只能取1.0克，以后取花生酱的数量不能少于两个人已经取过的总数量且不能超过两个人已经取过的总数量的三倍；
4、不能按规则3取花生酱的人必须吃掉瓶子里的花生米；
 5、为显示规则的公平性，Jerry可以选择先取或者后取。
Jerry当然希望瓶子里的花生米被Tom吃掉。请计算，Jerry为了达到目的应该先取还是后取。

输入：本题有多个测例，每个测例的输入是一个浮点数w，w大于1.0小于等于1000.0，w最多只有一位小数，代表花生酱的数量，单位为克。
w小于0表示输入结束，不需要处理。

输出：每个测例在单独的一行内输出一个整数：Jerry先取输出1；Tom先取输出0。

输入样例：

1.5
7.9
-1

输出样例：

1
0

#include <iostream>
using namespace std;
int main()
{
    int a[10001]; 
    float w;
    int i, j, k; 
    while(cin >> w && w > 1)
    {
        for (i = w * 10; i > 9; i--) 
        {
            j = w * 10 - i;
            if (j < i)
            {
                a[i] = 0;
            }
            else if (j <= 3 * i)
            {
                a[i] = 1;
            }
            else if (j > 3 * i)
            {
                a[i] = 0;
                for (k = i; k <= 3 * i; k++)
                {
                    if (a[(int)i + k] == 0)
                    {
                        a[i] = 1;
                        break;
                    }
                }
            }
        }
        cout << 1-a[10] <<endl;;
    }
    return 0;
}