week13-作业

A - TT 的神秘任务1

题意

这一天，TT 遇到了一个神秘人。

神秘人给了两个数字，分别表示 n 和 k，并要求 TT 给出 k 个奇偶性相同的正整数，使得其和等于 n。

例如 n = 10，k = 3，答案可以为 [4 2 4]。

TT 觉得这个任务太简单了，不愿意做，你能帮他完成吗？

本题是SPJ

输入

第一行一个整数 T，表示数据组数，不超过 1000。

之后 T 行，每一行给出两个正整数，分别表示 n（1 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 100）。

输出

如果存在这样 k 个数字，则第一行输出 “YES”，第二行输出 k 个数字。

如果不存在，则输出 “NO”。

样例输入

8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9

样例输出

YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120

思路

该问题需要进行分类讨论：

• 奇数不可以由偶数个数组成，可以由奇数k个奇数构成 1，1，1，，，n-(k-1)
• 偶数可以有偶数k个奇数构成 1,1,1,n-(k-1)
• 偶数也可以由奇数k个偶数构成 2，2，2，，，n-2*(k-1) 这里需要注意2*k>n 否则不够分

代码

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
	int t,n,k;cin>>t;int num[110];
	while(t--)
	{
		cin>>n>>k;
		if((n%2&&k%2==0)||k>n)
		{
			cout<<"NO"<<endl;
			continue;
		}
		if((n%2&&k%2)||(n%2==0&&k%2==0))
		{	//奇数		
			for(int i=0;i<k;i++)
			{
				if(i==k-1) num[i]=n-(k-1);
                else num[i]=1;
			}
		}
		if(n%2==0&&k%2)
		{	
			if(n<2*k)
			{
				cout<<"NO"<<endl;
				continue;
			}
			for(int i=0;i<k;i++)
			{
				if(i==k-1) num[i]=n-2*(k-1);
				else num[i]=2;
			}
		}
		cout<<"YES"<<endl;
		for(int i=0;i<k;i++)
		cout<<num[i]<<" ";
		cout<<endl;  
	}  return 0;
} 

B - TT 的神秘任务2

题意

在你们的帮助下，TT 轻松地完成了上一个神秘任务。

但是令人没有想到的是，几天后，TT 再次遇到了那个神秘人。

而这一次，神秘人决定加大难度，并许诺 TT，如果能够完成便给他一个奖励。

任务依旧只给了两个数字，分别表示 n 和 k，不过这一次是要求 TT 给出无法被 n 整除的第 k 大的正整数。

例如 n = 3，k = 7，则前 7 个无法被 n 整除的正整数为 [1 2 4 5 7 8 10]，答案为 10。

好奇的 TT 想要知道奖励究竟是什么，你能帮帮他吗？

输入

第一行一个整数 T，表示数据组数，不超过 1000。

之后 T 行，每一行给出两个正整数，分别表示 n（2 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 1e9）。

输出

对于每一组数据，输出无法被 n 整除的第 k 大的正整数。

样例输入

6
3 7
4 12
2 1000000000
7 97
1000000000 1000000000
2 1

样例输出

10
15
1999999999
113
1000000001
1

思路

需要给出无法被 n 整除的第 k 大的正整数。
又因为1n 2n 3n…可以被n整除，所以当x<1n或者在1n-2n 2n-3n…之间，所以这里根据k计算第k大的正整数在哪个位置即可。因为n,k的数据范围很大，所以这里可以用二分查找或者计算数学公式都可。

代码

#include<iostream>
#include<cstdio>
using namespace std;
int main()
{int t;scanf("%d",&t);
  while(t--)
  {
  	long long n,k;scanf("%lld%lld",&n,&k);
  	//cout<<n<<" "<<k<<endl;
  	if(k<n)
  	{
  		cout<<k<<endl;continue;
	  }
	  long long m=k/n;
	long long l=m,r=1000000000;long long ans=1000000000;
	while(l<=r)
	{
		long long mid=(l+r)/2;
		if(mid*n-(mid-1)<=k)
		l=mid+1;
		else 
		{ 
		 ans=mid;//cout<<ans<<"*"<<endl;
			r=mid-1;
		}
	}
  		cout<<(ans-1)*n+k-((ans-1)*n-(ans-1))<<endl;

  }return 0;
	
 } 

C - TT 的奖励

题意

输入

多组样例。每组样例输入一个 m (0 < m < 100000)，表示有 m 只猫咪。

在接下来的 m 行中，每行有两个整数 a b (0 < b < 100000)，表示在第 b 秒的时候有一只猫咪掉落在 a 点上。

注意，同一个点上同一秒可能掉落多只猫咪。m = 0 时输入结束。

输出

输出一个整数 x，表示 TT 可能接住的最多的猫咪数。

样例输入

6
5 1
4 1
6 1
7 2
7 2
8 3
0

样例输出

4

思路

因为每一秒的每一个状态的前一个状态都是可以确定的，所以可以用动规去求解这道题。

• 状态定义
  dp[i][j]表示第j秒在i位置收获的猫咪数。
• 转移方程
  dp[i][j]=max(dp[i][j-1],dp[i-1][j-1],dp[i+1][j-1])+vis[i][j]

总结

动规思想即小问题解->大问题解

代码

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
#define ssize 100020
int vis[15][ssize];int dp[15][ssize];
int main()
{   int m;
	while(cin>>m)
	{  
		if(m==0)break; memset(vis,0,sizeof(vis));int maxt=0;
		for(int i=1;i<=m;i++)
		{
			int a,b;cin>>a>>b;maxt=max(maxt,b);
            vis[a][b]++;
		}
		memset(dp,0,sizeof(dp));
		dp[4][1]=vis[4][1];dp[5][1]=vis[5][1];dp[6][1]=vis[6][1];
		for(int i=2;i<=maxt;i++)
		{
			for(int j=0;j<=10;j++)
			{
				if(j==0)
				dp[j][i]=max(dp[j][i-1],dp[j+1][i-1])+vis[j][i];
				else if(j==10)
				dp[j][i]=max(dp[j][i-1],dp[j-1][i-1])+vis[j][i];
				else
				dp[j][i]=max(dp[j][i-1],max(dp[j-1][i-1],dp[j+1][i-1]))+vis[j][i];
			}
			
		}int mmmax=0;
		for(int i=0;i<=10;i++)
		mmmax=max(mmmax,dp[i][maxt]);
		cout<<mmmax<<endl;
		
		
	}return 0;
}

树形DP-----TT的苹果树

题意

在大家的三连助攻下，TT 一举获得了超级多的猫咪，因此决定开一间猫咖，将快乐与大家一同分享。并且在开业的那一天，为了纪念这个日子，TT 在猫咖门口种了一棵苹果树。

一年后，苹果熟了，到了该摘苹果的日子了。

已知树上共有 N 个节点，每个节点对应一个快乐值为 w[i] 的苹果，为了可持续发展，TT 要求摘了某个苹果后，不能摘它父节点处的苹果。

TT 想要令快乐值总和尽可能地大，你们能帮帮他吗？

输入

结点按 1～N 编号。

第一行为 N (1 ≤ N ≤ 6000) ，代表结点个数。

接下来 N 行分别代表每个结点上苹果的快乐值 w[i]（-128 ≤ w[i] ≤ 127)。

接下来 N-1 行，每行两个数 L K，代表 K 是 L 的一个父节点。

输入有多组，以 0 0 结束。

输出

每组数据输出一个整数，代表所选苹果快乐值总和的最大值。

样例输入

7
1
1
1
1
1
1
1
1 3
7 4
2 3
4 5
6 4
3 5
0 0

样例输出

5

思路

• 定义状态：
• 定义 f[i][0/1] 表示以 i 为节点的子树所能得到的最大的气氛值。
• f[i][0] 表示以 i 为子树且未选择 i 号节点；
• f[i][1] 表示以 i 为子树且选择了 i 号节点
• 最终答案就是 max(f[root][0], f[root][1])

• 状态转移过程
• 不选取父节点，孩子节点可以参加，也可以不参加。
• 选取父节点，孩子节点只能不参加。
• 枚举量x为当前节点i到能直接到达的所有的子节点。

总结

树形DP，定义状态，设定状态转移方程，计算结果

代码

#include<iostream>
#include<vector>
#include<cstring>
# define inf 100000000
using namespace std;
vector<int>ve[6010];
int w[6010];int fa[6010];int f[6010][3];
int solve(int root,bool flag)
{  if(f[root][flag]!=inf)
     return f[root][flag];
     if(flag==0)
     {
     	int ans=0;
	for(int i=0;i<ve[root].size();i++)
	{
		if(ve[root][i]!=fa[root])
		{   f[ve[root][i]][1]=solve(ve[root][i],1);
		    f[ve[root][i]][0]=solve(ve[root][i],0);
			ans=ans+max(f[ve[root][i]][1],f[ve[root][i]][0]);
		}
	}
	return f[root][0]=ans;
	 }
    else{
    	int	ans=0;
	for(int i=0;i<ve[root].size();i++)
	{
		if(ve[root][i]!=fa[root])
		{   f[ve[root][i]][0]=solve(ve[root][i],0);
			ans=ans+f[ve[root][i]][0];
		}
	}return f[root][1]=ans+w[root];
//	return max(f[root][1],f[root][0]);
	}

}
int main()
{
	int n;
	while(cin>>n)
	{
		if(n==0) break;
		for(int i=0;i<6010;i++)
		ve[i].clear();
		memset(w,0,sizeof(w));
		for(int i=0;i<6010;i++)
		{
			for(int j=0;j<3;j++)
			f[i][j]=inf;
		}
		for(int i=1;i<=n;i++)
		cin>>w[i];//cout<<"**"<<endl;
		for(int i=1;i<n;i++)
		{
			int a,b;cin>>a>>b;
			fa[a]=b;
			ve[a].push_back(b);
			ve[b].push_back(a);		
		}int root;
		for(int i=1;i<=n;i++)
		if(fa[i]==0) root=i;
		int res=max(solve(root,1),solve(root,0));
		cout<<res<<endl;
		
	}
	
}

E-TT的神秘任务

题意

TT 猫咖的生意越来越红火，人越来越多，也越来越拥挤。

为了解决这个问题，TT 决定扩大营业规模，但猫从哪里来呢？

TT 第一时间想到了神秘人，想要再次通过完成任务的方式获得猫咪。

而这一次，神秘人决定加大难度。

给定一个环，A[1], A[2], A[3], … , A[n]，其中 A[1] 的左边是 A[n]。要求从环上找出一段长度不超过 K 的连续序列，使其和最大。

这一次，TT 陷入了沉思，他需要你们的帮助。

输入

第一行一个整数 T，表示数据组数，不超过 100。

每组数据第一行给定两个整数 N K。（1 ≤ N ≤ 100000, 1 ≤ K ≤ N）

接下来一行，给出 N 个整数。（-1000 ≤ A[i] ≤ 1000）。

输出

对于每一组数据，输出满足条件的最大连续和以及起始位置和终止位置。

如果有多个结果，输出起始位置最小的，如果还是有多组结果，输出长度最短的。

样例输入

4
6 3
6 -1 2 -6 5 -5
6 4
6 -1 2 -6 5 -5
6 3
-1 2 -6 5 -5 6
6 6
-1 -1 -1 -1 -1 -1

样例输出

7 1 3
7 1 3
7 6 2
-1 1 1

思路

总结

反思