week(11) 作业——背包专题

A-必做题11-1

题目描述

蒜头君从现在开始工作，年薪 N 万。他希望在蒜厂附近买一套 60 平米的房子，现在价格是 200 万。假设房子价格以每年百分之 K 增长，并且蒜头君未来年薪不变，且不吃不喝，不用交税，每年所得 N万全都积攒起来，问第几年能够买下这套房子？（第一年年薪 N 万，房价 200万）

输入格式

一行，包含两个正整数 N(10≤N≤50)，K(1≤K≤20)，中间用单个空格隔开。

输出格式

如果在第 20 年或者之前就能买下这套房子，则输出一个整数 M，表示最早需要在第 M 年能买下；否则输出"Impossible"。

输出时每行末尾的多余空格，不影响答案正确性

样例

Input

50 10

Output

8

解题思路

每次循环更新房价p的值，n不变（注意k要设成float类型，否则房价每年的增长为0），直到n×i>p，输出年份i。若20年仍未攒够钱，输出“impossible”。

代码

#include<iostream>

using namespace std;

int n;
float k,p=200;

int main() {
	cin>>n>>k;
	for(int i=1;i<=20;++i) {
		if(i*n>=p) {
			cout<<i<<endl;
			return 0;
		}
		p+=p*(k/100);
	}
	cout<<"Impossible"<<endl;
	return 0;
}

B-必做题11-2

题目描述

蒜头君的班级里有 n^2 个同学，现在全班同学已经排列成一个 n∗n的方阵，但是老师却临时给出了一组新的列队方案

为了方便列队，所以老师只关注这个方阵中同学的性别，不看具体的人是谁

这里我们用 0 表示男生，用 1 表示女生

现在蒜头君告诉你同学们已经排好的方阵是什么样的，再告诉你老师希望的方阵是什么样的

他想知道同学们已经列好的方阵能否通过顺时针旋转变成老师希望的方阵

1.不需要旋转则输出 0

2.顺时针旋转 90° 则输出 1

3.顺时针旋转 180° 则输出 2

4.顺时针旋转 270° 则输出 3

若不满足以上四种情况则输出 −1

若满足多种情况，则输出较小的数字

输入格式

第一行为一个整数 n

接下来的 n 行同学们已经列好的 01 方阵；

再接下来的 n 行表示老师希望的的 01 方阵。

输出格式

输出仅有一行，该行只有一个整数，如题所示。

数据范围

对于 100% 的数据中，1≤n≤20

输出时每行末尾的多余空格，不影响答案正确性

样例

Input

4
0 0 0 0
0 0 0 0
0 1 0 0
0 0 0 0
0 0 0 0
0 1 0 0
0 0 0 0
0 0 0 0

Output

1

解题思路

二维数组a存储已排好方阵，b存储老师希望的方阵。

1. 不需旋转直接依次遍历比较判段a[i][j]==b[i][j]？即可；
2. 顺时针旋转90°比较式子为：判断a[i][j]==b[j][n+1-i]？
3. 顺指针旋转180°：判断a[i][j]==b[n+1-i][n+1-j]？
4. 顺时针旋转270°即逆时针旋转90°：判断a[i][j]==b[n+1-j][i]？

注意： 每轮比较后重置flag

代码

#include<iostream>

using namespace std;

int a[21][21],b[21][21];
int n;

int main() {
	cin>>n;
	bool flag=1;
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j)
			cin>>a[i][j];
	}
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j) {
			cin>>b[i][j];
			if(flag&&a[i][j]!=b[i][j])
				flag=0;
		}
	}
	if(flag) {
		cout<<"0"<<endl;
		return 0;
	}
	flag=1;
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j) {
			if(a[i][j]!=b[j][n+1-i]) {
				flag=0;
				break;
			}	
		}
		if(!flag) break;
	}
	if(flag) {
		cout<<"1"<<endl;
		return 0;
	}
	flag=1;
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j) {
			if(a[i][j]!=b[n+1-i][n+1-j]) {
				flag=0;
				break;
			}	
		}
		if(!flag) break;
	}
	if(flag) {
		cout<<"2"<<endl;
		return 0;
	}
	flag=1;
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=n;++j) {
			if(a[i][j]!=b[n+1-j][i]) {
				flag=0;
				break;
			}	
		}
		if(!flag) break;
	}
	if(flag) {
		cout<<"3"<<endl;
		return 0;
	}
	cout<<"-1"<<endl;
	return 0;
} 

C-必做题11-3

题目描述

Julius Caesar 曾经使用过一种很简单的密码。对于明文中的每个字符，将它用它字母表中后 5 位对应的字符来代替，这样就得到了密文。比如字符’A’用’F’来代替。如下是密文和明文中字符的对应关系。

密文A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

明文V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

你的任务是对给定的密文进行解密得到明文。

你需要注意的是，密文中出现的字母都是大写字母。密文中也包括非字母的字符，对这些字符不用进行解码。

输入格式

一行，给出密文，密文不为空，而且其中的字符数不超过 200。

输出格式

输出一行，即密文对应的明文。

输出时每行末尾的多余空格，不影响答案正确性

样例

Input

NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX

Output

IN WAR, EVENTS OF IMPORTANCE ARE THE RESULT OF TRIVIAL CAUSES

解题思路

1. 只解码A-Z的字符（即65<=s[i]<=90）
2. 对A-E中的字符-5后要加上26
3. 用getline()获取整行字符串

代码

#include<iostream>
#include<string>

using namespace std;

string s;

int main() {
	getline(cin,s);
	for(int i=0;i<s.size();++i) {
		if(s[i]>=65&&s[i]<=90) {
			if(s[i]>=70) s[i]-=5;
			else s[i]=s[i]-5+26;
		}
	}
	cout<<s;
	return 0;
}

D-必做题11-4

题目描述

东东和他的女朋友(幻想的)去寿司店吃晚餐(在梦中)，他发现了一个有趣的事情，这家餐厅提供的 n 个的寿司被连续的放置在桌子上 (有序)，东东可以选择一段连续的寿司来吃

东东想吃鳗鱼，但是东妹想吃金枪鱼。核 平 起 见，他们想选择一段连续的寿司（这段寿司必须满足金枪鱼的数量等于鳗鱼的数量，且前一半全是一种，后一半全是另外一种）我们用1代表鳗鱼，2代表金枪鱼。

比如，[2,2,2,1,1,1]这段序列是合法的，[1,2,1,2,1,2]是非法的。因为它不满足第二个要求。

东东希望你能帮助他找到最长的一段合法寿司，以便自己能吃饱。

输入格式

输入：
第一行：一个整数n（2≤n≤100000），寿司序列的长度。
第二行：n个整数（每个整数不是1就是2，意义如上所述）

输出格式

输出：一个整数（代表东东可以选择的最长的一段连续的且合法的寿司）

Example

Input1

7
2 2 2 1 1 2 2

Output1

4

Input2

6
1 2 1 2 1 2

Output2

2

Input3

9
2 2 1 1 1 2 2 2 2

Output3

6

解题思路

• 输入时记录此次输入的数now并与上次的数last比较，如果相同，该数的计数cnt[i]++，仍在当前段；如果不同,num++记录当前子序列段依次出现的次数（一段表示一串相同的字）
• 若num=3（代码中为>2），将该序列前面与now相同的数的已出现次数置0，即子序列删掉last所属段的前一段数，因为此时的序列已形成三段数（相等的一串认为一段），不合法，将最前面的一段舍弃，子序列进入now所属的下一段
• ans记录对当前已知所有子序列中最大单数个数cnt[i]，ans×2即为当前已知的最长合法序列长
• 每次输入now，last更新为now

代码

#include<iostream>
#include<algorithm>

using namespace std;

int n,cnt[3],ans=0;

int main() {
	cin>>n;
	int last=0,now=0,num=0;
	for(int i=1;i<=n;++i) {
		cin>>now;
		if(last!=now) num++;
		if(num>2) {
			cnt[now]=0;
			num--;
		}
		cnt[now]++;
		ans=max(ans,min(cnt[1],cnt[2]));
		last=now;
	}
	cout<<ans*2<<endl;
	return 0;
}

E-选做题11-1 东东与ATM

题目描述

一家银行计划安装一台用于提取现金的机器。
机器能够按要求的现金量发送适当的账单。
机器使用正好N种不同的面额钞票，例如D_k，k = 1,2,…,N，并且对于每种面额D_k，机器都有n_k张钞票。
例如，
N = 3，
n_1 = 10，D_1 = 100，
n_2 = 4，D_2 = 50，
n_3 = 5，D_3 = 10
表示机器有10张面额为100的钞票、4张面额为50的钞票、5张面额为10的钞票。
东东在写一个 ATM 的程序，可根据具体金额请求机器交付现金。
注意，这个程序计算程序得出的最大现金少于或等于可以根据设备的可用票据供应有效交付的现金。

输入格式

程序输入来自标准输入。 输入中的每个数据集代表特定交易，其格式为：Cash N n1 D1 n2 D2 … nN DN其中0 <= Cash <= 100000是所请求的现金量，0 <= N <= 10是 纸币面额的数量，0 <= nk <= 1000是Dk面额的可用纸币的数量，1 <= Dk <= 1000，k = 1，N。 输入中的数字之间可以自由出现空格。 输入数据正确。

输出格式

对于每组数据，程序将在下一行中将结果打印到单独一行上的标准输出中。

Sample

Input

735 3 4 125 6 5 3 350
633 4 500 30 6 100 1 5 0 1
735 0
0 3 10 100 10 50 10 10

Output

735
630
0
0

hint

第一个数据集指定一笔交易，其中请求的现金金额为 735。 机器包含3种面额的纸币：4张钞票 125、6张钞票 5和3张钞票 350。 机器可以交付所需现金的确切金额。

在第二种情况下，机器的票据供应不能满足所要求的确切现金数量。 可以交付的最大现金为 630。 请注意，在机器中组合钞票以匹配交付的现金有多种可能性。

在第三种情况下，机器是空的，没有现金交付。 在第四种情况下，请求的现金金额为 0，因此机器不交付现金。

解题思路

面额为D_k的钞票有n_k张，共N种钞票，组合出少于或等于要求的金额的最大交付现金。
这是一道很明显的多重背包问题，基本解法是——采用进制的思想将n_k进行二进制拆分，然后转换成0-1背包问题。

• 二进制拆分
  首先考虑最简单情况n_k=7=（111）二进制，那么可以将7简单拆成（001），（010），（100），即十进制的1D_k，2D_k，4*D_k。通过对这三组进行选/不选的0-1背包的决策，就能涵盖所有0-n_k中的决策，最终将n_k张面额为D_k的钞票拆分成cnt=log(n_k)+1种钞票。具体拆分算法见代码。

• 滚动数组
  用一维滚动数组f[cash]，逆序枚举j=cash->0，循环cnt次结束后f[j]即为下式定义的状态f[i][j]
  
  对于此题，状态转移公式为：f[j]=max(f[j],f[j-v[i]]+v[i]);

此题是容量至多为cash的问题，最终结果为f[cash]
最终复杂度优化为O(NcashΣlog(n_k))

代码

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

int n,cash;
int nk[11],dk[11],v[110],f[100010]; 

int main() {
	while(cin>>cash) {
		memset(v,0,sizeof(v));
		memset(f,0,sizeof(f));
		cin>>n;
		for(int i=1;i<=n;++i) 
			cin>>nk[i]>>dk[i];
			
		//二进制拆分
		int cnt=0;
		for(int i=1;i<=n;++i) {
			int t=nk[i];
			for(int k=1;k<=t;k<<=1) {
				cnt++;
				v[cnt]=k*dk[i];
				t-=k;
			}
			if(t>0) {
				cnt++;
				v[cnt]=t*dk[i];
			}
		} 
		//滚动数组0/1背包 
		for(int i=1;i<=cnt;++i) {
			for(int j=cash;j>=0;--j)
				if(j-v[i]>=0)
					f[j]=max(f[j],f[j-v[i]]+v[i]);
		}
		cout<<f[cash]<<endl;
	}
	return 0;
}

F-选做题11-2 东东开车了

题目描述

东东开车出去泡妞(在梦中)，车内提供了 n 张CD唱片，已知东东开车的时间是 n 分钟，他该如何去选择唱片去消磨这无聊的时间呢

假设:

• CD数量不超过20张
• 没有一张CD唱片超过 N 分钟
• 每张唱片只能听一次
• 唱片的播放长度为整数
• N 也是整数

我们需要找到最能消磨时间的唱片数量，并按使用顺序输出答案（必须是听完唱片，不能有唱片没听完却到了下车时间的情况发生）

本题是 Special Judge

输入格式

多组输入

每行输入第一个数字N, 代表总时间，第二个数字 M 代表有 M 张唱片，后面紧跟 M 个数字，代表每张唱片的时长 例如样例一: N=5, M=3, 第一张唱片为 1 分钟, 第二张唱片 3 分钟, 第三张 4 分钟

所有数据均满足以下条件:

N≤10000
M≤20

输出格式

输出所有唱片的时长和总时长，具体输出格式见样例

Sample

Input

5 3 1 3 4
10 4 9 8 4 2
20 4 10 5 7 4
90 8 10 23 1 2 3 4 5 7
45 8 4 10 44 43 12 9 8 2

Output

1 4 sum:5
8 2 sum:10
10 5 4 sum:19
10 23 1 2 3 4 5 7 sum:55
4 10 12 9 8 2 sum:45

解题思路

这是一个0-1背包问题同时涉及路径输出。

• 因为路径要输出每个所选CD的时长，这里不宜再采用一维滚动数组（无法回溯查找），采用0-1背包基本的二维数组记录每次的状态，同时对该状态下此CD选不选用二维数组flag标记，若该状态下选了CD_i,则flag[i][j]=1。
• 这道题也是容量至多为n的问题，输出路径，从f[m][n]开始查找，cd=m,mi=n，对任一状态若flag[cd][mi]=1，表明该CD_i被选中，加入ans数组，更新状态mi=mi-a[cd]，cd–；若flag为0，表明该CD未被选中，状态更新f[cd-1][mi]。
• 最终逆序输出ans数组即可。
• 时间复杂度和空间复杂度都是O(NxM)

代码

#include<iostream>
#include<cstring>

using namespace std;

int n,m,a[30],f[10010];
int flag[30][10010],ans[30];

int main() {
	while(cin>>n) {
		memset(f,0,sizeof(f));
		memset(flag,0,sizeof(flag));
		cin>>m;
		for(int i=1;i<=m;++i) 
			cin>>a[i];
		
		for(int i=1;i<=m;++i) {
			for(int j=n;j>=a[i];--j) {    
				if(f[j]<f[j-a[i]]+a[i]) {
					f[j]=f[j-a[i]]+a[i];
					flag[i][j]=1;
				}
			}
		}
		int cd=m,mi=n,cnt=0;
		while(cd>=1&&mi>=0) {
			if(flag[cd][mi]) {
				mi-=a[cd];
				ans[++cnt]=a[cd];
			}
			cd--;
		}
		//反向输出 
		for(int i=cnt;i>=1;--i) 
			cout<<ans[i]<<" ";
		cout<<"sum:"<<f[n]<<endl;
	}
	return 0;
}

这里添加递归回溯的代码：

• 选了:f[x][y] == f[x - 1][y - cd[x]] + a[x]
• 未选：f[x][y] == f[x - 1][y]

void rback(int x, int y) {
	if (x <= 0 || y <= 0)return;

	if (f[x][y] == f[x - 1][y])rback(x - 1, y);	//未选择第x张cd
	else if (f[x][y] == f[x - 1][y - a[x]] + a[x]) {	//选择了第x张cd
		rback(x - 1, y - a[x]);
		printf("%d ", a[x]);
	}
}