第二周acm（4/20）

A - 分宝石

有6种宝石，价值分别为1，2，3，4，5，6。
现在有一个长度为6的数组，第i个数字表示价值为i的宝石的数量。
例如：[1，0，1，2，0，0]表示有一个价值为1的宝石，一个价值为3的宝石和两个价值为4的宝石。
请判断能否将所有宝石分为两部分，使得两部分价值相等。
注意：宝石不能分割，比如价值为6的宝石不能分割为两个价值为3的宝石。

Input
每一行输入描述一个要划分的宝石集合。
每个集合有6个非负整数a1, a2，…， a6，其中ai为价值i的宝石数量。
宝石的最大总数将是20000。
输入文件的最后一行为’’ 0 0 0 0 0 "; 不用处理此行。

Output
对于每一行输入，输出Collection #k:, 其中k表示第一个样例（从1开始），然后输出Can be divided.（可以分成两部分）或者Can’t be divided.（不可以分成两部分）。
在每个测试用例之后输出一个空行。

Sample Input
1 0 1 2 0 0
1 0 0 0 1 1
0 0 0 0 0 0
Sample Output
Collection #1:
Can’t be divided.

Collection #2:
Can be divided.

#include<iostream>
using namespace std; 
int n[7];
int SumValue; 
int HalfValue; 
bool flag;   
void DFS(int value,int pre)
{
	if(flag)
		return;
	if(value==HalfValue)
	{
		flag=true;
		return;
	}
	for(int i=pre;i>=1;i--)
	{
		if(n[i])
		{
			if(value+i<=HalfValue)
			{
			
				n[i]--;
				DFS(value+i,i);
				if(flag)
					break;
			}
		}
	}
	return;
}
int main()
{
	int i,test=1;
	while(cin>>n[1]>>n[2]>>n[3]>>n[4]>>n[5]>>n[6])
	{
		SumValue=0; 
 
		for(i=1;i<=6;i++)
			SumValue+=i*n[i];
 
		if(SumValue==0)
			break;
 
		if(SumValue%2) 
		{
			cout<<"Collection #"<<test++<<':'<<endl;
			cout<<"Can't be divided."<<endl<<endl;    
			continue;
		}
		HalfValue=SumValue/2;
		flag=false;
		DFS(0,6);
		if(flag)
		{
			cout<<"Collection #"<<test++<<':'<<endl;
			cout<<"Can be divided."<<endl<<endl;
			continue;
		}
		else
		{
			cout<<"Collection #"<<test++<<':'<<endl;
			cout<<"Can't be divided."<<endl<<endl;
			continue;
		}
	}
    system("pause");
	return 0;
}

B - 补提交卡（贪心）

蒜头君给自己定了一个宏伟的目标：连续 100 天每天坚持在计蒜客题库提交一个程序。100 天过去了，蒜头君查看自己的提交记录发现有 N 天因为贪玩忘记提交了。于是蒜头君软磨硬泡、强忍着花椰菜鄙视的眼神从花椰菜那里要来M张 “补提交卡”。每张 “补提交卡” 都可以补回一天的提交，将原本没有提交程序的一天变成有提交程序的一天。蒜头君想知道通过利用这M张补提交卡，可以使自己的 “最长连续提交天数” 最多变成多少天。
输入格式
第一行是一个整数 T(1≤T≤10)，代表测试数据的组数。
每个测试数据第一行是 2个整数 N和 M(0≤N,M≤100)。
第二行包含 N个整数 a1,a2……aN(1≤a1<a2<…<aN≤100)，表示第 a1,a2……aN天蒜头君没有提交程序。
输出格式
对于每组数据，输出通过使用补提交卡蒜头君的最长连续提交天数最多变成多少。
Sample Input
3
5 1
34 77 82 83 84
5 2
10 30 55 56 90
5 10
10 30 55 56 90
Sample Output
76
59
100

plan1

不知道为什么过不了

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int t1;
    cin>>t1;
    while(t1--)
    {   
        int n,m;
        cin>>n>>m;
        if(m>=n){
			cout<<100<<endl;
			continue;
		}
        int a[100],sum,i;
        for(i=0;i<n;i++) cin>>a[i];
        sort(a,a+n);
        sum=a[m];
			for(i=0;i<n-m-1;i++)
				sum=max(sum,a[i+m+1]-a[i]);
			sum=max(sum,100-a[n-m]);
            cout<<sum-1<<endl;
    }
    system("pause");
    return 0;
}

plan2

这就过了

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
main()
{
	int t,i,sum,n,m;
	int a[100]; scanf("%d",&t);
	while(t--)
	{
		sum=0;a[0]=0;
		scanf("%d%d",&n,&m);
		for(i=1;i<=n;i++)
            scanf("%d",&a[i]);
		sort(a+1,a+1+n);
	    if(n<=m)
			printf("100\n");
		else
		{
			sum=a[m+1];
			for(i=0;i<n-m;i++)
				sum=max(sum,a[i+m+1]-a[i]);
			sum=max(sum,100-a[n-m]);
            if(sum==100-a[n-m])
                printf("%d\n",sum);
            else
                printf("%d\n",sum-1);
        }
    }
    system("pause");
    return 0;
}

C - 热血格斗场

蒜头君新开了一家热血格斗场。格斗场实行会员制，但是新来的会员不需要交入会费，而只要同一名老会员打一场表演赛，证明自己的实力。
我们假设格斗的实力可以用一个正整数表示，成为实力值。另外，每个人都有一个唯一的 id，也是一个正整数。为了使得比赛更好看，每一个新队员都会选择与他实力最为接近的人比赛，即比赛双方的实力值之差的绝对值越小越好，如果有两个人的实力值与他差别相同，则他会选择比他弱的那个（显然，虐人必被虐好）。

不幸的是，蒜头君一不小心把比赛记录弄丢了，但是他还保留着会员的注册记录。现在请你帮蒜头君恢复比赛纪录，按照时间顺序依次输出每场比赛双方的 id。

输入格式
第一行一个数n(0 < n <=100000)，表示格斗场新来的会员数（不包括facer）。以后n行每一行两个数，按照入会的时间给出会员的id和实力值。一开始，facer就算是会员，id为1，实力值1000000000。输入保证两人的实力值不同。
输出
N行，每行两个数，为每场比赛双方的id，新手的id写在前面。
Sample Input
3
2 1
3 3
4 2
Sample Output
2 1
3 2
4 2

E - 数列极差

题目描述
佳佳的老师在黑板上写了一个由 n 个正整数组成的数列，要求佳佳进行如下操作：每次擦去其中的两个数 a 和 b，然后在数列中加入一个数 a×b+1，如此下去直至黑板上剩下一个数为止，在所有按这种操作方式最后得到的数中，最大的为 max，最小的为 min， 则该数列的极差定义为 M=max−min。
由于佳佳忙于准备期末考试，现请你帮助他，对于给定的数列，计算出相应的极差 M。
输入格式
第一行为一个正整数 n 表示正整数序列的长度；
在接下来的 n 行中，每行输入一个正整数。
接下来的一行有一个 0，表示数据结束。
输出格式
输出只有一行，为相应的极差 d。
样例

Input	Output
3	2
1
2
3
0

数据范围与提示
对于全部数据，0≤n≤50000，保证所有数据计算均在 32 位有符号整数范围内。

plan1 18ms 380kb length:574

#include<iostream>
#include<algorithm>
using namespace std;
bool cmpmax(int a,int b)
{
    return a>b;
}
bool cmpmin(int a,int b)
{
    return a<b;
}
int main()
{
    int n,j,max,min;
    cin >> n;
    int arr[n+1],arr2[n+1];
    for(int i=0;i<=n;i++)
    {
        cin>>arr[i];
        arr2[i]=arr[i];
    }
    for (int j=0;j<n;j++)
    {
        sort(arr+j,arr+n,cmpmax);
        arr[j+1]=(arr[j]*arr[j+1])+1;
        sort(arr2+j,arr2+n,cmpmin);
        arr2[j+1]=(arr2[j]*arr2[j+1])+1;
    }
    min=arr[n-1];
    max=arr2[n-1];
    cout <<max-min<<endl;
    system("pause");
    return 0;
}

题外话+（思路）

定义两个数组，一个算最小值，一个算最大值。
经过思考不难发现每次取最小的两个值进行运算时，可得到max
每次取最大的两个值运算，可得到min
即每次对数组进行排序取最大或最小值，即用内置函数sort（别忘了加头文件algorithm）
sort(array_start,array_last,cmp)
以下内容为废话
这道题看了一下午，开始理解错误，以为写出的数组与黑板上写的数不在一起，看题一定要认真
这到题居然是贪心算法长见识了

G - 过河

题目描述
UCAS_ACM小组的N名成员外出旅游，结果在路上碰到了一条河，岸边只有一艘船，这艘船最多只能载两人。
已知N名成员每人有一个过河时间ti，每次划船过河的时间等于船上成员的过河时间的最大值。请你找N名成员全部到底对岸的最少耗时。
输入
输入包含多组测试数据。第一行含有一个正整数T，表示数据组数。
每组数据的第一行含有一个整数N。接下来的一行含有N个整数，表示ti。
输出
对于每组输入数据输出一行，每行包括1个整数，代表该组数据下到对岸的最少耗时。
样例输入
2
4
1 2 5 10
5
1 2 8 7 6
样例输出
17
22
数据范围
1≤T≤20
1≤N≤1000
1≤ti≤100

plan1

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[1000];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,i,j,m,sum=0;
        scanf("%d",&n);
        for(i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
        }
        sort(a+1,a+1+n);
        m=n;
        while(m>0)
        {
            if(m>=4)
            {
                if(a[m]+a[m-1]+2*a[1]>a[2]+a[1]+a[m]+a[2])
                {
                    sum+=a[2]+a[1]+a[m]+a[2];
                }
                else
                {
                    sum+=a[m]+a[m-1]+2*a[1];
                }
                m-=2;
            }
            else if(m==3)
            {
                sum+=a[m]+a[1]+a[2];
                break;
            }
            else if(m==2)
            {
                sum+=a[m];
                break;
            }
            else if(m==1)
            {
                sum+=a[m];
                break;
            }
            
        }
        printf("%d\n",sum); 
    }
    system("pause");
    return 0;
}

题外话+思路

a[m]+a[m-1]+2*a[1]>a[2]+a[1]+a[m]+a[2] 这是最关键的一步，
首先排序有小到大
第一种情况
a[m] a[1] ->过去
a[1] <- 过来
a[m-1] a[1] ->过去
a[1] <- 过来
第二种情况
a[1] a[2] ->先过去
a[1] <- 过来
a[m] a[m-1] ->过去
a[2]<- 过来
循环上述两种情况，直到出现m<4
以下内容为废话
这就是贪心吗，要死了

贪心

歇一歇