Dp on Zs's Blog

树形dp例题

Thu, 20 Feb 2020 01:04:00 +0000

前言

学OI的时候就做过树形dp的题，不过那时候全在划水。看了看题解还不太懂就直接照着题解写了，现在再回来看还是不会QAQ，所以就再看看然后自己写了一遍。

A. 没有上司的舞会

题意

有 $N$ 个职员被邀请去参加公司的舞会，他们每个人对应着一个快乐指数 $h_i$ ，如果该职员来了就会为舞会增加$h_i$ 点快乐指数。这 $N$ 个职员之间有从属关系，也就是说他们的关系就像一棵以顶级上司为根的树，父结点就是子结点的直接上司。如果一个职员的直接上司来到了舞会，那么他本人就不会再来。问邀请哪些职员可获得最大的快乐指数，最大为多少。

思路

职员之间的关系是以树的形式给出的，所以先用链式前向星来存储数。存的时候我们用vis数组记录一下如何那个人有上司，就将他标记一下，最终没有标记的就是没有上司的，也就是顶级上司，也就是我们的根节点root。树形dp，顾名思义，在树上进行dp，通过递归dfs，先算出子树的状态，再通过递归的回溯来合并。那么我们考虑一下设计状态，很明显一个人的状态有来和不来，两个情况。所以我们设计状态 $dp[i][0/1]$ 来表示职员 i 来或者不来，我们用u来表示当前节点，用v来表示当前节点的子节点，那么状态转移如下：

$dp[u][0]=max(dp[v][0],dp[v][1]) $ （上司u没有来，那么下属v可以来，也可以不来，选一个大的策略）
$dp[u][1]=dp[v][0]+h[u]$ （上司u来了，下属v肯定不来）

最终的答案就是 $max(dp[root][0],dp[root][1])$ ，上司来和不来两种策略中的最大一种。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=6005;
int head[maxn];
struct edge
{
	int next;
	int to;
}e[maxn];
int cnt,n,l,k,vis[maxn],root;
int r[maxn];
int dp[maxn][2];
void add(int l,int k)
{
	e[++cnt].next=head[l];
	e[cnt].to=k;
	head[l]=cnt;
}
void dfs(int u)
{
	dp[u][0]=0;
	dp[u][1]=r[u];
	for(int i=head[u];i;i=e[i].next)
	{
		int v=e[i].to;
		dfs(v);
		dp[u][1]+=dp[v][0];
		dp[u][0]+=max(dp[v][1],dp[v][0]);
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&r[i]);
	for(int i=1;i<n;i++)
	{
		scanf("%d%d",&l,&k);
		add(k,l);
		vis[l]++;
	}
	scanf("%d%d",&l,&k);
	for(int i=1;i<=n;i++) 
	{ 
		if(!vis[i]) root=i;
	}
	dfs(root);
	printf("%d",max(dp[root][0],dp[root][1]));
	return 0;
}

B. 战略游戏

题意

小姜老师要建立一个树，树节点两两之间通过道路连接，他要在这些节点上放一些小人，每个小人可监管与该节点相连的道路，问最少放置多少小人可以监管所有道路。（数据保证0为根节点）

思路

这个题跟上个题有点像，首先我们也是用链式前向星把树给存下来，不过这个题的输入跟上道题有点不一样，本质都是一样的。因为我们只需要dfs下去，然后向上回溯的时候合并，所以只需要存单向边即可。对于一个节点我们也是有两种策略，选或者不选，那么我们也可以把状态写成 $dp[i][1/0]$ ，对应着 i 这个节点选或者不选，我们把当前节点看作u，子节点看作v，状态转移如下：

$dp[u][1]+=\Sigma (dp[v][0],dp[v][1]) +1$ （u选了，v选不选都可以，加上自身的1）
$dp[u][0]+=\Sigma dp[v][1]$ （如果u没有选，那么v一定要选，才能监管到u的道路）

很显然这个答案是 $min(dp[0][0],dp[0][1])$

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=1505;
struct edge
{
	int next,to;
}e[maxn];
int u,v;
int head[maxn];
int dp[maxn][2];
int num;
int n,cnt;
void add(int u,int v)
{
	e[++cnt].next=head[u];
	e[cnt].to=v;
	head[u]=cnt;
}
void dfs(int u)
{
	dp[u][1]=1;
	for(int i=head[u];i;i=e[i].next)
	{
		int v=e[i].to;
		dfs(v);
		dp[u][1]+=min(dp[v][1],dp[v][0]);
		dp[u][0]+=dp[v][1];
	} 
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d%d",&u,&num);
		for(int i=1;i<=num;i++)
		{
			scanf("%d",&v);
			add(u,v);
		}
	}
	dfs(0);
	printf("%d",min(dp[0][0],dp[0][1]));
	return 0;
}

C. 二叉苹果树

题意

有一颗二叉苹果树，也就是说树枝如果分叉，一定是分二叉。苹果树有 $n$ 个节点，树根编号为 1 。每个树枝上都有一定数量的苹果，如果最终保留 $q$ 根树枝，问最多能够保留多少苹果。

思路

这个树形dp要比上面的还要难一些，因为我们的状态不能够只考虑是否保留当前的树枝了，因为保留当前树枝也会有很多种关于保留子树枝选择。看了题解大佬的说法是，可以定义成 $f[u][j]$ 来表示 u 的子树上保留 j 条边时所能获得最大的苹果数。所以我们考虑一下转移方程，首先我们能保留的最大边数是当前子树所具有的所有树枝，对于一个节点下的两个树枝，我们可以选择取，或者不取，那么这就类似于一个背包问题，对于一定的容量（一定量的树枝），我们取几个树枝才能获得最大的价值。但是我们注意，对于一个节点u，我们如果要取他的节点v，那么我们u-v之间这个树枝一定要保留，不然会不能取得v，这是一个隐藏的条件。因此转移方程： $dp[u][i]=max(dp[u][i],dp[u][i-j-1]+dp[v][j]+w[u][v] $ ，$w[u][v]$为当前u-v树枝的苹果数。代码里面因为我懒得计算子树的树枝数了，所以就直接从最大的q来枚举了，就没考虑那么多，可能复杂度稍微高一点，但是高不到哪去其实QAQ…

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=105;
struct edge
{
	int next,to,w;
}e[maxn];
int n,cnt,q;
int u,v,w;
int dp[maxn][maxn];
int head[maxn];
void add(int u,int v,int w)
{
	e[++cnt].next=head[u];
	e[cnt].to=v;
	e[cnt].w=w;
	head[u]=cnt;
}

void dfs(int u)
{
	for(int i=head[u];i;i=e[i].next)
	{
		int v=e[i].to;
		dfs(v);
		for(int j=q;j>=0;j--)
		{
			for(int k=0;k<=j-1;k++)
			{
				dp[u][j]=max(dp[u][j],dp[u][j-1-k]+dp[v][k]+e[i].w);
			}
		}
	}
}
int main()
{
	scanf("%d%d",&n,&q);
	for(int i=1;i<n;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		add(u,v,w);
	}
	dfs(1);
	printf("%d",dp[1][q]);
	return 0;
}

dp练习

Tue, 18 Feb 2020 01:00:00 +0000

A. 矩阵取数游戏

题意

给定一个 $n\times m$ 的矩阵，其中每个元素为非负整数。每次你可以从每行的行首或行末取一个元素，得到的分数为当前元素的值 $a_{ij}\times 2^k$ ，$k$ 为当前是第几次取该行上的元素。问最大得分为多少。

思路

首先我们发现，虽然答案问的是 $n$ 行，但是我们发现，不同行之间是不会相互影响的，我们只需要讨论一行的情况，然后对每行都处理一遍就可以了。那么对于一行上的 $m$ 个元素，我们每一次取都有两种选择，一个是取行首，一个是取行尾。我们发现这是一个区间问题，对于区间 $[i,j]$ 的最优情况，我们可以从 $[i+1,j]$ 和 $[i,j-1]$ 这两个的最优情况转移过来，因此我们可以定义 $f[i][j]$ 是从第 $i$ 个元素到第 $j$ 的元素得分的最大值，然后从上述两个状态转移过来。还有一个问题就是我们的 $2^k$ 问题，我们考虑到大区间的最优值是从小区间转移来，也就是说小区间乘的指数高，大区间乘的指数低，我们又是从小区间推到大区间，转移一次就乘一次，最后肯定是大区间的少，小区间的多了。qwq因为这个题的次数可能很高，会爆long long，实在是不想写高精度，就用了__int128，第一次用，感觉还不错QAQ..

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=85;
int n,m;
__int128 map[maxn][maxn];
__int128 dp[maxn][maxn],ans;
void read(__int128 &x)
{
	x=0;
	char ch;
	ch=getchar();
	while(ch<'0'||ch<'0') ch=getchar();
	while(ch>='0'&&ch<='9')
	{
		x=x*10+ch-'0';
		ch=getchar();
	}
}
void out(__int128 x)
{
	if(x>=10) out(x/10);
	putchar(x%10+'0');
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++) read(map[i][j]);
	}
	for(int i=1;i<=n;i++)
	{
		for(int f=1;f<=m;f++)
		{
			for(int j=1;j<=m;j++) dp[f][j]=0;
		}
		for(int len=1;len<=m;len++)
		{
			for(int j=1;j+len-1<=m;j++)
			{
				int k=j+len-1;
				dp[j][k]=max(dp[j+1][k]*2+map[i][j]*2,dp[j][k-1]*2+map[i][k]*2);
			}
		}
		ans+=dp[1][m];
	}
	out(ans);
	return 0;
}

B. 关路灯

题意

在一条街道上有 $n$ 个路灯开着，他们可以看作分布在 $x$ 轴上，每个路灯有一定的坐标，也就是代表他们的位置。每个路灯也有一定的功率 $x$ ，代表一秒钟消耗多少电能。姜大佬初始位置在 $c$ ，他每天早晨出来关掉路灯。它可以先关左边的也可以先关右边的，他的行走速率是 $1m/s$ ，问最少消耗多少电能能关掉所有路灯。

思路

又是一道区间dp的题，那么我们可以思考一下，首先小姜老师肯定不能跳着关路灯，也就是说这个区间内中间的路灯都被关闭了，他会关一个区间的左端点或者右端点，而不会关这个区间外面的。那么我们就可以枚举区间长度来解决这个问题，从小的枚举到大的。那么我们思考一下如何定义这个状态。我们可以定义关闭区间 $[i,j]$ 的路灯，最少消耗电能为 $f[i][j]$ ，如果需要转移状态的话，我们想到，对于一个方向，小姜老师可以继续往前走，关掉前面那盏灯，也可以返回去，关闭它屁股后面那盏灯。因为是有两个方向的，所以我们可以拓宽一维，用 $f[i][j][0/1]$ 来表示小姜老师现在是在往左走还是往右走，那么很明显 $f[i][j][0]$ 这个状态可以从 $f[i+1][j][0/1]$ 来转移分别对应着小姜老师继续往前走关眼前的，和返回关屁股后的。相应的 $f[i][j][1]$ 就可以从 $f[i][j-1][0/1]$ ，转移的时候再加上消耗的电能即可！

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=55;
const int inf=100000000;
int n,c;
int lt[maxn]; //lantern pos
int en[maxn]; //energy 
int sum[maxn]; //prefix sum
int dp[maxn][maxn][2];
int calc(int i,int j)
{
	return sum[n]-(sum[j]-sum[i-1]);
}
int main()
{
	scanf("%d%d",&n,&c);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			for(int k=0;k<=1;k++) dp[i][j][k]=inf;
		}
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&lt[i],&en[i]);
		sum[i]=en[i]+sum[i-1];
	}
	dp[c][c][0]=dp[c][c][1]=0;
	for(int len=2;len<=n;len++)
	{
		for(int i=1;i+len-1<=n;i++)
		{
			int j=i+len-1;
			dp[i][j][0]=min(dp[i+1][j][0]+(lt[i+1]-lt[i])*calc(i+1,j),dp[i+1][j][1]+(lt[j]-lt[i])*calc(i+1,j));
			dp[i][j][1]=min(dp[i][j-1][0]+(lt[j]-lt[i])*calc(i,j-1),dp[i][j-1][1]+(lt[j]-lt[j-1])*calc(i,j-1));
		}
	}
	printf("%d",min(dp[1][n][0],dp[1][n][1]));
	return 0;
}

C. 小a和uim之大逃离

题意

给定一个 $n\times m$ 的矩阵，每个格子中有 $0\sim k$ 滴魔液，小姜老师和它朋友可以从任意地点开始，一起向右或者向下走，他们每个人有一个容量为 $k$ 的瓶子，由小姜老师开始轮流收集地上的魔液，当收集魔液大于 $k$ 的时候，会对 $k+1$ 取模，问他们有多少种方法使得收集的魔液数量相同。

思路

很显然我们可以写一个5维dp，用 $f[i][j][p][l][0/1]$ 来表示，当到了坐标为 $(i,j)$ 的格子的时候，小姜老师拥有魔液 $p$ 滴，他的朋友拥有魔液 $l$ 滴，并且这一次是由小姜老师采集的/由他的朋友采集的。这样的话，感觉比较好些，但是。。空间占用非常的高，我们优化一下，因为问的是收集相等，所以只需要维护他们的差就可以了，也就是说，只需要将 $(p-l+k)\%k$ 维护一下就可以了，因此循环枚举坐标以及他们的差，从低的向高的转移就可以了。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=805;
int map[maxn][maxn];
int dp[maxn][maxn][16][2];
const int mod=1e9+7;
int n,m,k;
long long ans;
int main()
{
//	freopen("test.in","r",stdin);
	scanf("%d%d%d",&n,&m,&k);
	k++;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			scanf("%d",&map[i][j]);
			dp[i][j][map[i][j]%k][0]=1;
		}
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			for(int t=1;t<=k;t++)
			{
				dp[i][j][t%k][0]+=dp[i-1][j][(t-map[i][j]+k)%k][1];dp[i][j][t%k][0]%=mod;
				dp[i][j][t%k][0]+=dp[i][j-1][(t-map[i][j]+k)%k][1];dp[i][j][t%k][0]%=mod;
				dp[i][j][t%k][1]+=dp[i-1][j][(t+map[i][j])%k][0];dp[i][j][t%k][1]%=mod;
				dp[i][j][t%k][1]+=dp[i][j-1][(t+map[i][j])%k][0];dp[i][j][t%k][1]%=mod;
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			ans+=dp[i][j][0][1]%mod;
			ans%=mod;
		}
	}
	printf("%lld",ans);
}

dp习题练习

Wed, 12 Feb 2020 00:45:00 +0000

A. 方格取数

题意

有一个 $N*N$ 的整数方阵，每个点初始值为0，在一些点上放上数，一个人从左上角走到右下角，规定只能向下或向右走，当他经过的点上有数时会取走它，问走两遍最多能取的数的和最大为多少。

思路

也就是说我们要找两条路径使他取数最大，首先我一开始想法是先走一遍，找到最大的那个路径，将这条路径上所有点设为0，然后再回来找这个方阵中最大的那个路径，两个加起来就行。但是路径上所有的点设为0这个地方不是很好实现，因此我们可以考虑另一个思路，两次同时走。我们把这两次看成两个人走的，表述方便。我们用 $dp[i][j][k][l]$ 来表示当第一个人走到 $(i,j)$ 第二个人走到 $(k,l)$ 时做能取数最多为多少，那么我们就可以考虑一下转移怎么转移，因为到达一个点只能是从左边来，或者是从上边来，因此第一个人从 $(i-1,j)$ 或者 $(i,j-1)$ 转移来，那么第二个人就从 $(k-1,l)$ 或者 $(k,l-1)$ 转移来，那么这个转移方程就是四种转移方式。我们需要保证一个问题，就是他俩经过同一个点的判定情况。我们需要将第二个人的坐标通过第一个人来限制，也就是说要确保第二个人和第一个人步数是相同的，当他们步数相同的时候，那么就不存在他们经过同一个点但是时间却是不同的情况了，因为到达一个点的步数是一定的。再就是这个状态数组其实还是可以压缩到三维和二维的，这个就先不谈了，可以看洛谷的题解区。这个题是一个经典的多维dp的题目，感觉还是挺有意义的。而且这个题和传纸条很像，可以双倍经验。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=15;
int map[maxn][maxn];
int n,x,y,z;
int m;
int dp[maxn][maxn][maxn][maxn];
int main()
{
	scanf("%d",&n);
	while(1)
	{
		scanf("%d%d%d",&x,&y,&z);
		if(x==0&&y==0&&z==0) break;
		map[x][y]=z;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			for(int k=1;k<=n;k++)
			{
				m=i+j-k;
				if(m<=0) continue;
				if(i==k&&j==m) dp[i][j][k][m]=max(max(dp[i-1][j][k-1][m],dp[i-1][j][k][m-1]),max(dp[i][j-1][k-1][m],dp[i][j-1][k][m-1]))+map[i][j];
				else dp[i][j][k][m]=max(max(dp[i-1][j][k-1][m],dp[i-1][j][k][m-1]),max(dp[i][j-1][k-1][m],dp[i][j-1][k][m-1]))+map[i][j]+map[k][m];
			}
		}
	}
	printf("%d",dp[n][n][n][n]);
	return 0;
}

B. 创意吃鱼法

题意

给出一个 $N*M$ 的只包含0和1的数阵，求只有对角线为1，其余位置为0的子方阵的最大边长。

思路

这个题我们需要考虑两个方向，这个对角线既可以是斜向左上，也可以是斜向右上的。我们先考虑前者，后者同理即可。我们可以用两个数组 $col[i][j]$ 和 $row[i][j]$ 分别来表示，包含 $(i,j)$ 这个点往上一列有多少个0，以及包含这个点往左一行有多少个0，（这个在程序里好像我写反了，但是没啥区别说实话）。然后我们用 $f[i][j]$ 来表示，从这个点左上走满足条件的方阵的最大边长。那么很显然这个值和上方的0，左方的0，以及左上的状态有关，这个点是1的话，转移方程就是 $f[i][j]=min(f[i-1][j-1],min(col[i-1][j],row[i][j-1]))+1$ 。如果是0的话我们就更新 $col$ 和 $row$ 数组的值。然后求完斜向左上的再求一遍斜向右上的，取一个最大值即可。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=2505;
int n,m;
int map[maxn][maxn];
int col[maxn][maxn],row[maxn][maxn];
int dp[maxn][maxn];
int ans;
int main()
{
//	freopen("test.in","r",stdin);
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			scanf("%d",&map[i][j]);
		if(!map[i][j])
		{
			row[i][j]=row[i-1][j]+1;
			col[i][j]=col[i][j-1]+1;
		}
		else 
		{
			dp[i][j]=min(dp[i-1][j-1],min(row[i-1][j],col[i][j-1]))+1;
			ans=max(dp[i][j],ans);
		}
		}
	}
	memset(row,0,sizeof(row));
	memset(col,0,sizeof(col));
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++)
	{
		for(int j=m;j>=1;j--)
		{
			if(!map[i][j])
			{
				row[i][j]=row[i-1][j]+1;
				col[i][j]=col[i][j+1]+1;
			}
			else
			{
				dp[i][j]=min(dp[i-1][j+1],min(row[i-1][j],col[i][j+1]))+1;
				ans=max(ans,dp[i][j]);
			}
		}
	}
	printf("%d",ans);
}

C. 乌龟棋

题意

给出标号分别为1，2，3，4的四种卡片若干张，分别可以移动1，2，3，4步，玩家初始处于坐标为1的位置。玩家出一张牌，可移动相应的步数。移动到不同的坐标会加不同的分数，很明显不同的出牌顺序会对应着不同的分数，求玩家能获得的最大分数为多少。

思路

很显然我们可以通过已经出的牌计算出现在已经到达到哪个位置。我们可以用一个四重循环，来循环每张牌用的数量，很明显我们到达一个目标位置所用的最后一张牌可以是1，2，3，4的任何一个，因此我们可以从这个四个状态转移过来，找其中最大那个就可以了，注意要判断一下要转移过来的状态是否合法。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=355;
const int maxm=125;
int n,m,pos;
int w[maxn];
int x,num[5];
int dp[42][42][42][42];
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) scanf("%d",&w[i]);
	for(int i=1;i<=m;i++)
	{
		scanf("%d",&x);
		num[x]++;
	} 
	memset(dp,-1,sizeof(dp));
	dp[0][0][0][0]=w[1];
	for(int a=0;a<=num[1];a++)
	{
		for(int b=0;b<=num[2];b++)
		{
			for(int c=0;c<=num[3];c++)
			{
				for(int d=0;d<=num[4];d++)
				{
					pos=1+a+(b<<1)+c*3+(d<<2);
					if(a>0&&dp[a-1][b][c][d]!=-1)
					{
						dp[a][b][c][d]=max(dp[a][b][c][d],dp[a-1][b][c][d]+w[pos]);
					}
					if(b>0&&dp[a][b-1][c][d]!=-1)
					{
						dp[a][b][c][d]=max(dp[a][b][c][d],dp[a][b-1][c][d]+w[pos]);
					}
					if(c>0&&dp[a][b][c-1][d]!=-1)
					{
						dp[a][b][c][d]=max(dp[a][b][c][d],dp[a][b][c-1][d]+w[pos]);
					}
					if(d>0&&dp[a][b][c][d-1]!=-1)
					{
						dp[a][b][c][d]=max(dp[a][b][c][d],dp[a][b][c][d-1]+w[pos]);
					}
				}
			}
		}
	}
	printf("%d",dp[num[1]][num[2]][num[3]][num[4]]);
	return 0;
}

D. 能量项链

题意

给出一段含有 $n$ 个珠子的环状项链，对于相邻的两个珠子，前一颗珠子的尾标记等于后方珠子的头标记。例如项链为 $[2,4,6,8]$ ，那么用加入标记表示就是 $[(2,4),(4,6),(6,8),(8,2)]$ 。当两个珠子两两合并的时候会产生的能量大小为前方珠子头标记 $\times$ 前方珠子尾标记 $\times$ 后方珠子尾标记。显然合并的顺序不同最终会产生不同的能量值，问能产生的最大能量值为多少。

思路

这道题和合并石子很像，也是一个区间dp的例题，我们也是通过枚举区间长度，然后枚举区间断点来分割区间。这个题也是一个环状，我们也是断环为链，不过处理释放的能量值的问题，我是用了一个结构体，来表示每一颗珠子的标记，通过这个来计算释放能量。不过记得处理子区间也要从处理到 $1\sim 2n$，这个地方卡了我巨长时间，因为你后面要用到这个状态，如果不计算子区间无法转移到后面。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

typedef long long ll;
const int maxn=105;
int n;
ll dp[maxn<<1][maxn<<1];
struct node
{
	ll w;
	ll nxt;
}a[maxn<<1];
int main()
{
//	freopen("test.in","r",stdin);
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%lld",&a[i].w);
		a[i+n].w=a[i].w;
	}
	for(int i=1;i<=n*2-1;i++)
	{
		a[i].nxt=a[i+1].w;
	}
	for(int i=1;i<=2*n;i++) dp[i][i]=0;
	for(int p=2;p<=n;p++)
	{
		for(int i=1;i<=2*n-p+1;i++) //重要(卡我巨长时间)
		{
			int j=i+p-1;
			for(int k=i;k<j;k++)
			{
				dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]+a[i].w*a[k].nxt*a[j].nxt);
			}
		}
	}
//	for(int i=1;i<=n;i++)
//	{
//		printf("%d ",dp[i][i+1]);
//	}
	ll ans=0;
	for(int i=1;i<=n;i++) ans=max(ans,dp[i][i+n-1]);
	printf("%lld",ans);
	return 0;
}

背包进阶

Sun, 09 Feb 2020 00:38:00 +0000

1. 分组背包

题意

在01背包基础上，将其中的物体分成 $k$ 组，每组内的物品相互冲突，即只能取其中一个，问最大价值。

思路

同一组中各个物品是相互排斥的，那么我们对于处理可以外层循环组别，然后循环体积，最后循环组内的物品，然后套用01背包的转移方程 $dp[i]=max(dp[i],dp[i-v[k]]+w[k])$ 即可。我们来思考一下他的正确性，为什么只要这样循环就能确保每个组最多只取用一种呢？很明显组内的我们对于同一个体积 $V$ ，求体积 $V$ 对应的最大价值的时候，是从这个组内所有物品中取了能获得最大价值的策略，很明显当我们转移任何一个 $dp[i-v[k]]$ 的状态的时候，他们其中都不包含第 $i$ 组的物品，都是只包含了前 $i-1$ 组的物品，因为我们最终取得最大价值的路径是确定的，因此通过这个方式我们就可以确保每个组内只取一种，但是如果体积和组内物品的循环调换过来，就不行了，因为之前的状态就会包含当前组内的其他物品。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn =1005;
const int maxt = 105; 
struct item
{
	int a,b;
}p[maxt][maxn];
int cnt[maxt];
int n,m;
int dp[maxn];
int q,w,e,maxe;
int main()
{
	scanf("%d%d",&m,&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d%d",&q,&w,&e);
		cnt[e]++;
		p[e][cnt[e]].a=q;
		p[e][cnt[e]].b=w;
		maxe=max(maxe,e);
	}
	for(int i=1;i<=maxe;i++)
	{
		for(int j=m;j>=0;j--)
		{
			for(int k=1;k<=cnt[i];k++)
			{
				if(j>=p[i][k].a)
				dp[j]=max(dp[j],dp[j-p[i][k].a]+p[i][k].b);
			}
		}
	}
	printf("%d",dp[m]);
}

2. 有依赖的背包

题意

在01背包的基础上给物品加上依赖，某个物品可能为附件，必须买了主件之后才能买。规定一个物品最多有两个附件，并且附件不会再有附件，也不存在循环依赖（附件再依赖于主件）。问能获得的最大价值为多少。

思路

这道题有三种思路，难度依次递增。

这道题的附件很少，可能为0，1，2。那么我们就在01背包的基础上，分五种情况来转移，分别是都不买，只买一个主件，只买主件和附件1，只买主件和附件2，买主件和两个附件。然后在这个基础上取一个最大的即可。但是这个思路对于附件可以很多的情况，就会特别麻烦。
第二种思路是转化成分组背包，我们注意到对于每一个主件和附件的搭配都是唯一的，也就是每种方案都是互斥的。好比最多那五种情况，我们就可以分成一组。然后进行分组背包即可。那么我们分组的时候，可以考虑到一个优化，也就是如果他们的体积相同，我们只需要选价值大的那个就可以啦。所以我们先对主件和附件这个集合，进行01背包，然后背出来相同体积下最大价值的方案，分到对应组里。这个思路对于附件也有附件的情况，就不好写了，不能直接01背包。
第三种思路可以应对附件也有附件的情况，可以用森林来表示所有物品之间的关系，然后树上dp做。然而，我不会。QAQ…

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=32005;
const int maxm=65;
int n,m;
int num[maxm];
struct Item
{
	int v,p,q;
}item[maxm],minor[maxm][maxm];
int dp[maxn],cnt[maxm];
int vi[maxm][maxm],pi[maxm][maxm];
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&item[i].v,&item[i].p,&item[i].q);
		if(item[i].q)
		{
			num[item[i].q]++;
			minor[item[i].q][num[item[i].q]].v=item[i].v;
			minor[item[i].q][num[item[i].q]].p=item[i].v*item[i].p;
		}
	}
	for(int i=1;i<=m;i++)
	{
		if(num[i])
		{
			memset(dp,-1,sizeof(dp));
			dp[0]=0;
			for(int j=1;j<=num[i];j++)
			{
				for(int k=n-item[i].v;k>=minor[i][j].v;k--)
				{
					if(dp[k-minor[i][j].v]!=-1)
					{
						dp[k]=max(dp[k],dp[k-minor[i][j].v]+minor[i][j].p);	
					}
				}
			}
			for(int k=0;k<=n-item[i].v;k++)
			{
				if(dp[k]!=-1)
				{
					cnt[i]++;
					vi[i][cnt[i]]=k+item[i].v;
					pi[i][cnt[i]]=dp[k]+item[i].v*item[i].p;
				}
			}
		}
		if(!item[i].q)
		{
			cnt[i]++;
			vi[i][cnt[i]]=item[i].v;
			pi[i][cnt[i]]=item[i].v*item[i].p;
		}
	}
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=m;i++)
	{
		if(!cnt[i]) continue;
		for(int j=n;j>=0;j--)
		{
			for(int k=1;k<=cnt[i];k++)
			{
				if(j>=vi[i][k])
				{
					dp[j]=max(dp[j],dp[j-vi[i][k]]+pi[i][k]);
				}
			}
		}
	}
//	int ans;
//	for(int i=1;i<=n;i++) ans=max(ans,dp[i]);
	printf("%d",dp[n]);
	return 0;
}

3. 多米诺骨牌(隐式背包)

题意

多米诺骨牌有上下两个部分，分别具有一定点数。所有多米诺骨牌上部分点数之和与下部分点数之和差的绝对值为 $x$ ，多米诺骨牌可以进行上下翻转，问当 $x$ 最小的时候最少翻转几次。

思路

害，本来好像没有隐式背包这个说法，我自己瞎起的名字。。其实就是没那么裸的背包，实际上转化一下还是道背包的题。这道题本来其实看起来和背包没有什么关系，但是实际想一想，假如我们把所有多米诺骨牌一开始都调成上面大下面小的情况，然后调整过的把他的消耗值设为-1，没有调整过的把消耗值设为1。达成上大下小目的需要消耗的次数为n。调整后的上下点数差为V。我们每次调整之后 $V$ 会减少牌的上下点数之差，这就是我们需要的体积。然后一开始把 $dp[V]$ 设为n。然后转移方程为 $dp[i]=min(dp[i],dp[i+v[i]]+w[i]) $ 最后只需要求从 $0\sim V$ 最小的那个点数差对应的翻转次数值就可以了。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=1005;
int ini;
int n;
int up[maxn],down[maxn];
int v[maxn],w[maxn];
int dp[10005];
int V;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&up[i],&down[i]);
		if(up[i]>=down[i])
		{
			V+=up[i]-down[i];
			v[i]=(up[i]-down[i])*2;
			w[i]=1;
		}
		else
		{
			V+=down[i]-up[i];
			ini++;
			v[i]=(down[i]-up[i])*2;
			w[i]=-1;
		}
	}
	for(int i=0;i<=V;i++) dp[i]=233333;
//	dp[V]=ini;
	dp[V]=ini;
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<=V-v[i];j++)
		{
			if(dp[j+v[i]]!=233333)
			dp[j]=min(dp[j],dp[j+v[i]]+w[i]);
		}
	}
	for(int i=0;i<=V;i++)
	{
		if(dp[i]!=233333)
		{
			printf("%d",dp[i]); 
			break;
		}
	}
	return 0;
}

一些关于背包的题

Sat, 08 Feb 2020 00:33:00 +0000

前言

今天跟着背包九讲把背包再学习一下，dd_engi大佬的背包九讲Github链接: 背包九讲

1. 采药(01背包)

题意

有 $n$ 个价值为 $w_i$ ，体积为 $v_i$ 的物品，装入体积为 $V$ 的背包中，问能获得的最大为多少。

思路

首先我们可以用 $f[i][j]$ 来定义前 $i$ 个物品放入体积为 $j$ 的背包中能获得最大体积，对于每一个物品，我们可以分两种情况来讨论，分别是装和不装，然后取他们两个的最大值。已经正确的定义了状态，转移方程就不难写出来了，是 $f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i])$ ，然后推的话就直接外层循环物品，内层循环体积递推即可。最后 $f[n][V]$ 就是我们需要的答案。

但是看了大佬们的题解，他们说，空间复杂度还可以再优化，那么我们可以看看如果优化的话，肯定是不能去掉体积那一维的，所以就是去掉第几个物品那一维。所以从 $f[i][j]$ 变成了 $f[j]$ 。那么我们想想，当我们推第 $i$ 个物体的状态的时候，我们需要已知第 $i-1$ 个的状态，我们物体循环是 $1\sim n$ 那么肯定 $f[i][j]$ 一开始对应的是 $f[i-1][j]$ ，那么如果顺推体积 $0\sim V$ 的话我们可以发现，当我们推 $f[i][j]$ 需要状态 $f[i-1][j-v[i]]$ 的时候，这时候如果直接调用 $f[j-v[i]]$ 对应的是 $f[i][j-v[i]]$ 也就是说，这不是我们需要的结果，这时候的状态可能已经取过一次i了，那么我们就可以逆推体积 $V\sim c[i]$ ，这样我们调用 $f[j-v[i]]$ 就刚好对应的是没取过 $i$ 的情况了！最后推出来 $f[V]$ 就是对应的答案了！

代码实现

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>

using namespace std;

const int maxn=105;
int t,m;
int f[1005];
int a[maxn],b[maxn];
int main()
{
    scanf("%d%d",&t,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&a[i],&b[i]);
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=t;j>=a[i];j--)
        {
            f[j]=max(f[j],f[j-a[i]]+b[i]);
        }
    }
    printf("%d",f[t]);
    return 0;
}

2. 疯狂的采药(完全背包)

题意

有 $n$ 种价值为 $w_i$ ，体积为 $v_i$ 的物品，每一种物品有无数个，装入体积为 $V$ 的背包中，问能获得的最大为多少。

思路

那么很显然我们可以把一个它转化成 $\sum_{i=1}^n \lfloor{\frac{V}{v_i}}\rfloor$ 个物品的01背包，也可以在取每个物体的时候循环 $\lfloor{\frac{V}{v_i}}\rfloor$ 次，但是我们可以思考对上述01背包的优化，我们发现如果顺着取，刚好对应的就是我们需要的状态，也就是说我们只需要将 $V$ 的循环正过来就可以了！

代码实现

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>

using namespace std;

const int maxn=100005;
int t,m;
int f[100005];
int a[maxn],b[maxn];
int main()
{
    scanf("%d%d",&t,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&a[i],&b[i]);
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=a[i];j<=t;j++)
        {
            f[j]=max(f[j],f[j-a[i]]+b[i]);
        }
    }
    printf("%d",f[t]);
    return 0;
}

3. 宝物筛选(多重背包)

题意

有 $N$ 种物品和一个容量为 $V$ 的背包。第 $i$ 种物品最多有 $m_i$ 件可用，每件耗费的空间是 $v_i$，价值是 $w_i$ 。求解将哪些物品装入背包可使这些物品的耗费的空间总和不超过背包容量，且价值总和最大。

思路

那么这道题裸的做法就是对于转移 $f[v]$ 这个方程的时候，考虑取多少个物品，可以取一个，可以取两个，在不超过体积情况下最多取 $m[i]$ 个，转移方程 $f[v]=max(f[v],f[v-k*v[i]])\quad k\in[1,m_i]$ 。那么这样其实时间复杂度还是很高的，所以大佬们给出了优化方案

第一种就是把 $m_i$ 个物品进行二进制拆分，把他们拆成 $1$，$2^1$，$2^2$ ····等等，一直拆到不能再拆，这样我们就能够将 $m_i$ 个物品拆成 $log(m_i)$ 个物品，但是他们还是能够表示出所有的情况。然后就继续01背包背一下就可以了。
单调队列优化，我不会，我太菜了。。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,ans,cnt;
int a,b,c;
const int maxn=1000005;
int f[maxn];
int w[maxn],v[maxn];
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        for(int j=1;j<=c;j*=2) //二进制拆分
        {
            v[++cnt]=j*a;
			w[cnt]=j*b;
            c-=j;
        }
        if(c) 
		{
			v[++cnt]=a*c;
			w[cnt]=b*c;
		}
	}
    for(int i=1;i<=cnt;i++)
   	{
   		for(int j=m;j>=w[i];j--)
   		{
   			f[j]=max(f[j],f[j-w[i]]+v[i]);
		}
	} 
    printf("%d\n",f[m]);
    return 0;
}

基础线性dp例题 #2

Fri, 07 Feb 2020 00:22:00 +0000

1. 石子归并

题意

$N$ 堆石子摆成一条线。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将 $N$ 堆石子合并成一堆的最小代价。

思路

很经典的区间dp例题，我们可以用 $dp[i][j]$ 来表示合并 $i\sim j$ 所需的最小代价，通过枚举中间的断点，来通过方程 $dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+cost[i][j])$ ，其中 $cost[i][j]$ 表示从 $i\sim j$ 的石子总数，通过前缀和很容易计算。在进行状态转移时需要前面状态已知，因为是枚举中间断点，所以断开区间的长度一定要小于原区间，因此在转移之前需要确保比他短的区间都已经达到了最小代价，因此我们可以通过枚举区间长度从 $2\sim N$ 来实现。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;
const int inf=1000005;
const int maxn=105;
int n;
int sum[maxn],a[maxn];
int dp[maxn][maxn];
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		sum[i]=sum[i-1]+a[i];
	}
	for(int i=1;i<=n;i++) dp[i][i]=0;
	for(int p=2;p<=n;p++)
	{
		for(int i=1;i<=n-p+1;i++)
		{
			int j=i+p-1;
			dp[i][j]=inf;
			for(int k=i;k<j;k++)
			{
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);
			}
		}
	}
	printf("%d",dp[1][n]);
	return 0;
}

2. P1880 [NOI1995]石子合并

题意

$N$ 堆石子摆成一个环。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将 $N$ 堆石子合并成一堆的最小代价和最大代价。

思路

这个题和上个题只有两个地方不同，一个是从线到环，一个是同时求最大和最小代价。害，其实这样也没变什么东西，也是跟上面一样，枚举区间长度和切割点。我们可以把一个环想象成一个链，如果这个环是由 N 个元素构成，那么这个链就由 N+N 个元素构成，这么这样就能确保你每次枚举区间的时候能取到合法的值，好比你要可以合并最后一个和第一个，那么就是对应的 $dp[n][n]+dp[n+1][n+1]+cost[n][n+1]$ 。不过这样最后寻找答案的时候肯定不只是 $dp[i][n]$ 了，你要从 $dp[1][n]\sim dp[n][n*2]$ 中寻找最优的答案。同时求最大和最小代价就直接开两个数组记录就可以了。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;
const int inf=1000005;
const int maxn=105;
int n;
int sum[maxn<<1],a[maxn<<1];
int ansmax,ansmin=12345678;
int dp[maxn<<1][maxn<<1],f[maxn<<1][maxn<<1]; //later is max , fromer is min 
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		a[i+n]=a[i];
		sum[i]=sum[i-1]+a[i];
	}
	for(int i=n+1;i<=2*n;i++)
	{
		sum[i]=sum[i-1]+a[i];
	 } 
	for(int i=1;i<=n*2;i++) dp[i][i]=f[i][i]=0;
	for(int p=2;p<=n;p++)
	{
		for(int i=1;i<=2*n-p+1;i++)
		{
			int j=i+p-1;
			dp[i][j]=inf;
			for(int k=i;k<j;k++)
			{
				dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);
				f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]+sum[j]-sum[i-1]);
			}
		}
	}
	for(int i=1;i<=n;i++) ansmax=max(ansmax,f[i][i+n-1]);
	for(int i=1;i<=n;i++) ansmin=min(ansmin,dp[i][i+n-1]);
	printf("%d\n%d",ansmin,ansmax);
	return 0;
}

3. P1140 相似基因

题意

有 $A : T :C : G $ 四种碱基，他们之间可以两两配对，特殊的，一个碱基也可以和空碱基配对，但是空碱基和空碱基配对是不被允许的，当不同的碱基间两两配对时，会具有一定的相似度，问给定两段序列 $s$，$t$ 能获得的最大相似度是多少。

碱基配对时相似度的定义如下

	A	C	G	T	空
A	5	-1	-2	-1	-3
C	-1	5	-3	-2	-4
G	-2	-3	5	-2	-2
T	-1	-2	-2	5	-1
空	-3	-4	-2	-1	非法

思路

首先用一个二维数组来存储对应的相似值表。因为对应的两段序列，我感觉这种题一般都是用 $dp[i][j]$ 来表示第一段序列从 $1\sim i$ 对应第二段序列 $1\sim j$ 所能获得的最大相似度，那么思考一下状态转移。

首先可以是碱基对空碱基，这时候 $s$ 要匹配碱基，$t$ 中匹配空碱基，这样的话就从应该从 $dp[i-1][j] $转移过来，对应的转移方程为 $dp[i][j]=max(dp[i][j],dp[i-1][j]+map[s[i]][blank])$
也可以是空碱基对碱基，对应的转移方程为$dp[i][j]=max(dp[i][j],dp[i][j-1]+map[blank][t[j]])$
也可以是碱基对碱基，对应的转移方程为$dp[i][j]=max(dp[i][j],dp[i-1][j-1]+map[s[i]][t[j]])$

害，想到这里我又突然懵逼了，我在想是否能确保两个序列所有的碱基都被用到，仔细想想确实是可以的，因为状态定义的就是用了前 $i$ 个碱基和前 $j$ 个碱基所获得的最大相似度。最后我们就处理一下边界就可以了，边界我们可以发现是 $dp[i][0]$ 和 $dp[0][i]$ ，这就是可以对应着空碱基和相应 $s[i]$ 和 $t[i]$ 的碱基，因此只需要用循环依次转移一遍就可以了。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;
const int inf=1000005;
const int maxn=105;
int n,m;
int a[maxn],b[maxn];
char s[maxn],c[maxn];
int dp[maxn][maxn];
const int map[5][5]={{5,-1,-2,-1,-3},
					 {-1,5,-3,-2,-4},
					 {-2,-3,5,-2,-2},
					 {-1,-2,-2,5,-1},
					 {-3,-4,-2,-1,0}}; //A 0 C 1 G 2 T 3 blank 4
int main()
{
	scanf("%d%s%d%s",&n,s+1,&m,c+1);
	for(int i=1;i<=n;i++)
	{
		if(s[i]=='A') a[i]=0;
		if(s[i]=='C') a[i]=1;
		if(s[i]=='G') a[i]=2;
		if(s[i]=='T') a[i]=3;
	} 
	for(int i=1;i<=m;i++)
	{
		if(c[i]=='A') b[i]=0;
		if(c[i]=='C') b[i]=1;
		if(c[i]=='G') b[i]=2;
		if(c[i]=='T') b[i]=3;
	}
	for(int i=1;i<=n;i++) dp[i][0]=dp[i-1][0]+map[a[i]][4];
	for(int i=1;i<=m;i++) dp[0][i]=dp[0][i-1]+map[4][b[i]];
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			dp[i][j]=-inf;
			dp[i][j]=max(dp[i][j],dp[i][j-1]+map[4][b[j]]);
			dp[i][j]=max(dp[i][j],dp[i-1][j]+map[a[i]][4]);
			dp[i][j]=max(dp[i][j],dp[i-1][j-1]+map[a[i]][b[j]]);
		}
	}
	printf("%d",dp[n][m]);
	return 0;
}

基础线性dp例题

Thu, 06 Feb 2020 00:09:00 +0000

前言

某位大佬曾经说过，dp不会没问题，想不到状态转移方程没问题，多做题就会了。所以，我打算多刷点dp题。那么，先从基础刷起吧。

1. P1091 合唱队形

题意

已知序列 $a$ 有 $n$ 个数，通过取出其中一些数可以使他满足严格的先增再减序列，问最少取出几个。

思路

很显然想要求最少取出几个，我们就看严格先增再减的序列的最长长度即可。我们可以用 $g[i]$ 来存储到 $a[i]$ 为止的最长递增子序列的长度，然后用 $l[i]$ 来存储从 $a[i]$ 到序列末尾最长的递减子序列的长度。处理 $g[i]$ 从前往后扫，处理 $l[i]$ 需要从后往前扫。处理完 $f$ 和 $g$ 数组那么就从左到右扫一遍，$ans=max(ans,g[i]+l[i]-1)$ 。答案即是 $n-ans$ 。

代码实现

#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<cstring>

using namespace std;

const int maxn=105;
int n;
int a[maxn],g[maxn],l[maxn];
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<i;j++)
		{
			if(a[i]>a[j]) g[i]=max(g[i],g[j]+1);
		}
	}
	for(int i=n;i>=1;i--)
	{
		for(int j=n+1;j>i;j--)
		{
			if(a[i]>a[j]) l[i]=max(l[i],l[j]+1);
		}
	}
	int maxout=0;
	for(int i=1;i<=n;i++)
	{
		maxout=max(maxout,g[i]+l[i]-1);
	}
	printf("%d",n-maxout);
	return 0;
}

2. P1280 尼克的任务

题意

尼克的一个工作日为 $n$ 分钟，从第一分钟开始到第 $n$ 分钟结束。当尼克到达单位后他就开始干活。如果在同一时刻有多个任务需要完成，尼克可以任选其中的一个来做，而其余的则由他的同事完成，反之如果只有一个任务，则该任务必需由尼克去完成，假如某些任务开始时刻尼克正在工作，则这些任务也由尼克的同事完成。如果某任务于第 $p$ 分钟开始，持续时间为 $t$ 分钟，则该任务将在第 $p+t-1$ 分钟结束。（实在不会总结题意，就直接复制过来了）

思路

我们可以设 $f[i]$ 为时间从 $i\sim n$ 所能获得最长空闲时间，最终 $f[1]$ 对应的就是答案。假设在这个 $i$ 分钟有 $k[i]$ 个任务可以，那么我们可以分以下情况转移

$k[i]=0$ ，那么 $f[i]=f[i+1]+1$
$k[i]\not=0$ ，那么可以循环 $1 \sim k[i]$ 遍历这个时间点开始的任务，$f[i]=max(f[i],f[i+k[i].t])$

思路是这样的，但是我们记录 $k[i].t$ 并不好记录，因此我们可以先将任务开始时间按降序排序，用一个一个变量 $cnt$ 来代表已经取到第几个任务了，那么这样一直取下去，最终就能够遍历所有的任务。

代码实现

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>

using namespace std;

const int maxn=10005;
struct task
{
	int l,r;
}t[maxn];
int cmp(struct task a,struct task b)
{
	return a.l>b.l;
}
int dp[maxn];
int p[maxn];
int cnt=1,n,k; 
int main()
{
	scanf("%d%d",&n,&k);
	for(int i=1;i<=k;i++)
	{
		scanf("%d%d",&t[i].l,&t[i].r);
		p[t[i].l]++;
	}
	sort(t+1,t+1+k,cmp);
	for(int i=n;i>=1;i--)
	{
		if(!p[i])
		{
			dp[i]=dp[i+1]+1;
		}
		else 
		{
			for(int j=1;j<=p[i];j++)
			{
				dp[i]=max(dp[i],dp[i+t[cnt].r]);
				cnt++;
			}
		}
	}
	printf("%d\n",dp[1]);
	return 0;
}

我太懒了····就写了两道，明天继续加油吧。。