NWPU-DP专题

原博客：http://phoenix-zh.cn/2020/07/22/NWPU-DP/

1.题目：

D - Proud Merchants

题目大意：

n种商品，m元钱，每种商品都有p,q,v属性，p价格，q表示买这种商品你需要带q元老板才愿意和你交易，v这种商品的实际价值。求问最多可以获得多少价值 。

思路：

如果p=q，那么就是01背包。但是如果p！=q， 如果A:p1 q1, B:p2 q2 ， 假设单独买A或者B的话，都是可以买到的 。 若先买A，则你至少需要p1+q2的钱；若先买B，则至少需要p2+q1的钱。 那肯定是花最少的钱 ，所以如果先买A再买B ， 那么p1+q2<p2+q1 转换一下，就是q1-p1>q2-p2 也就是说qi-pi大的先买。注意：排序的时候，得按照qi-pi从小到大排序，因为你买第n件商品的时候，是在比较你是否要先买第n件商品。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=5000+10;
struct N
{
	int p,q,v;
}a[maxn];
int n,m;
int cmp(N x,N y)
{
	return x.q-x.p<y.q-y.p;
}
int dp[maxn];
int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=n;i++)cin>>a[i].p>>a[i].q>>a[i].v;
		sort(a+1,a+1+n,cmp);
		for(int i=1;i<=n;i++)
		{
			for(int j=m;j>=a[i].q;j--)
			{
				dp[j]=max(dp[j],dp[j-a[i].p]+a[i].v);
			}
		}
		cout<<dp[m]<<endl;		
	}

	return 0;
}
//Phoenix-ZH

2.题目：

G - Knapsack 2

题目大意：

现有 N 个物品，序号分别为 1, 2, … , N。对于每个 i (1 ≤ i ≤ N)，物品 i 有一个体积 wi 和一个价值 vi。小明想在这 N 个物品中选取一些放到背包里带回家。已知背包的容积为 W，这意味着所带物品的总体积不能超过 W。求出小明可以带回家的物品总价值可能的最大值。

• 输入的所有数值均为整数。
• 1 ≤ N ≤ 100
• 1 ≤ W ≤ 10^9
• 1 ≤ wi ≤ W
• 1 ≤ vi ≤ 10^3

思路：

01背包问题，Knapsack 1是一个裸的01背包，但是这个题发现W的值特别大，直接N*W根本跑不掉。所以枚举W是不合理的。在Knapsack 1中设dp[i]：i为容量，dp[i]为容量为i时的最大价值。那么在Knapsack 2中，不妨反着来，设dp[i]:i指背包的价值为i，dp[i]指背包的价值为i时的最小容量。注意枚举价值（<=100000）时要倒着枚举（01背包）。将dp数组初始化为无限大，dp[0]是下界。当dp[j-v[i]]是可达的或者j-v[i]==0(即下界)时，可以更新dp[j]=min(dp[j],dp[j-v[i]]+w[i])。然后倒着求出最大的可达价值（要保证dp[i]<=m）。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const long long maxn=100000+50;
long long n,m,w[maxn],v[maxn],dp[maxn];
int main()
{
	cin>>n>>m;
	for(long long i=1;i<=n;i++)cin>>w[i]>>v[i];
	memset(dp,0x7f7f7f7f,sizeof(dp));
	dp[0]=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=100000;j>=v[i];j--)
		{
			if(dp[j-v[i]]||j-v[i]==0)
			{
				dp[j]=min(dp[j],dp[j-v[i]]+w[i]);
			}
		}
	}
	for(int j=100000;j>=1;j--)
	{
		if(dp[j]&&dp[j]<=m)
		{
			cout<<j<<endl;
			return 0;
		}
	}
	return 0;
}
//Phoenix-ZH

3.题目：

I - Longest Path

题目大意：

有一个有向图 G ，有 N 个顶点和 M 条边。顶点被编号为 1, 2, … , N，第 i 条有向边是从顶点xi 到顶点 yi (1 ≤ i ≤ M)。有向图 G 中 不包含有向环。
请找出G中最长有向路径的长度。最长有向路径的长度为它包含的边数量。

• 所有的输入都是整数
• 2 ≤ N ≤ 10^5
• 1 ≤ M ≤ 10^5
• 1 ≤ xi, yi ≤ N
• 每一对 (xi, yi) 都保证不相同
• G 不包含有向环.

思路：

直接用拓扑排序求最长路，先让所有入度为0的进队列，然后每次更新下一节点的路径长度，若入度减为0就入队列。最后线性地查一下最大地路径长度。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=100000+10;
struct node
{
	int to,next,w;
}edge[maxn];
int k=1,head[maxn],ind[maxn],n,m,dp[maxn];
void add(int u,int v,int w)
{
	edge[++k].to=v;edge[k].next=head[u];head[u]=k;edge[k].w=w;
}
void Topsort()
{
	queue<int>q;
	for(int i=1;i<=n;i++)
		if(!ind[i])
			q.push(i);
	while(!q.empty())
	{
		int x=q.front();q.pop();
		for(int i=head[x];i;i=edge[i].next)
		{
			dp[edge[i].to]=max(dp[edge[i].to],dp[x]+edge[i].w);
			ind[edge[i].to]--;
			if(!ind[edge[i].to])
				q.push(edge[i].to);
		}
	}
}
int  main()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		int u,v;
		cin>>u>>v;
		add(u,v,1);
		ind[v]++;
	}
	Topsort();
	int ans=0;
	for(int i=1;i<=n;i++)
		ans=max(ans,dp[i]);
	cout<<ans<<endl;
	return 0;
}
//Phoenix-ZH

4.题目：

K - 任务安排 1

题目大意：

有N个任务排成一个序列在一台机器上等待执行，它们的顺序不得改变。机器会把这N个任务分成若干批，每一批包含连续的若干个任务。从时刻0开始，任务被分批加工，执行第i个任务所需的时间是 Ti。另外，在每批任务开始前，机器需要S的启动时间，故执行一批任务所需的时间是启动时间S加上每个任务所需时间之和。
一个任务执行后，将在机器中稍作等待，直至该批任务全部执行完毕。也就是说，同一批任务将在同一时刻完成。每个任务的费用是它的完成时刻乘以一个费用系数Ci。
请为机器规划一个分组方案，使得总费用最小。

思路：

首先任务的顺序是不变的，变的是分组的数量，新的批次开始的时候回导致有启动时间。先考虑简单一点的方法设dp[i][j]：前个任务分成j组。那么对于第j组的第一个任务是哪一个是未知的，所以要枚举第j组的左边界，显然这个时间复杂度是O(n^3)，但是可以先写出来，再考虑优化。求出t[i]和c[i]的前缀和sumt[i]和sumc[i].dp[i][j]=min(dp[i][j],dp[k][j-1]+(s*j+sumt[i]) * (sumc[i]-sumc[k])).
即：

for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			for(int k=0;k<=i-1;k++)
			{
				dp[i][j]=min(dp[i][j],dp[k][j-1]+(j*s+sumt[i])*(sumc[i]-sumc[k]));
			}
		}
	}

然后我们再考虑对它进行优化：对于组数j它影响的始终是式子中的 (js+sumt[i]) * (sumc[i]-sumc[k])，如果我们每增加一组新的批次，都对后面的所有任务的代价都加上sc[i]就可以规避这个问题。所以可以优化成一维的：dp[i]表示第i个任务需要的代价，同时枚举最后一组的第一个任务，那么
dp[i]=min(dp[i],dp[k-1]+s * (sumc[n]-sumc[k-1])+sumt[i] * (sumc[i]-sumc[k-1])).即：

for(int i=1;i<=n;i++)
	{
		for(int k=1;k<=i;k++)
		{
			dp[i]=min(dp[i],dp[k-1]+s*(sumc[n]-sumc[k-1])+sumt[i]*(sumc[i]-sumc[k-1]));
		}
	}

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=5000+10;
int n,s,t[maxn],c[maxn],dp[maxn],sumc[maxn],sumt[maxn];
int main()
{
	cin>>n>>s;
	for(int i=1;i<=n;i++)cin>>t[i]>>c[i],sumc[i]=sumc[i-1]+c[i],sumt[i]=sumt[i-1]+t[i];
	memset(dp,0x3f3f3f3f,sizeof(dp));
	dp[0]=0;
/*	dp[0][0]=dp[0][1]=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			for(int k=0;k<=i-1;k++)
			{
				dp[i][j]=min(dp[i][j],dp[k][j-1]+(j*s+sumt[i])*(sumc[i]-sumc[k]));
			}
		}
	}
*/
	for(int i=1;i<=n;i++)
	{
		for(int k=1;k<=i;k++)
		{
			dp[i]=min(dp[i],dp[k-1]+s*(sumc[n]-sumc[k-1])+sumt[i]*(sumc[i]-sumc[k-1]));
		}
	}
/*
	int ans=0x3f3f3f3f;
	for(int i=1;i<=n;i++)
		ans=min(ans,dp[n][i]);
*/
	cout<<dp[n]<<endl;
	return 0;
}