目录
状态划分为最后一步，两个点分别向右、上移动（2^2），共四种情况。
一、数字三角形
Acwing1027 方格取数
思路：可以走两次，也可以同时走两条路，本次采用同时走的方式
令k为走的步数，即k==i1+j1=i2+j2。表示从两条路从（1,1）走到（i1，j1）（i2，j2）的最大值
状态划分为最后一步，两个点分别向右、上移动（2^2），共四种情况。
由于走过之后数被取走，因此取数时如果两个点重合了（i2==i1），则t只加一次。
#include<iostream>
#include<algorithm>
#include<cstring>
//k表示为i+j。。状态表示为两条路从1,1分别走到i1,j1、i2,j2的最大值
//状态划分为四种（2*2）
//如果两个点重叠了，t就只加一次，否则加两次
using namespace std;
const int N =12;
int f[2*N][N][N];
int w[N][N];
int n;
int main()
{
cin>>n;
int a,b,c;
while(cin>>a>>b>>c,a||b||c)
w[a][b]=c;
for(int k=2;k<=n+n;k++)
for(int i1=1;i1<=n;i1++)
for(int i2=1;i2<=n;i2++)
{
int j1=k-i1,j2=k-i2;
if(j1>=1&&j1<=n&&j2>=1&&j2<=n)
{
int t=w[i1][j1];
if(i1!=i2) t+=w[i2][j2];
int &x=f[k][i1][i2];
x=max(x,f[k-1][i1-1][i2-1]+t);
x=max(x,f[k-1][i1][i2-1]+t);
x=max(x,f[k-1][i1-1][i2]+t);
x=max(x,f[k-1][i1][i2]+t);
}
}
cout<<f[2*n][n][n];
return 0;
}
作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4036790/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。Acwing275.传纸条
总结：类似方格取数，不过严格要求不能走到同一个点，走过某个点之后数不会被取走。
//这里填你的代码^^
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N =55;
int g[N][N];
int f[2*N][N][N];
int n,m;
/*首先考虑路径有交集该如何处理。
可以发现交集中的格子一定在每条路径的相同步数处。因此可以让两个人同时从起点出发，每次同时走一步，这样路径中相交的格子一定在同一步内。
状态表示：f[k, i, j] 表示两个人同时走了k步，第一个人在 (i, k - i) 处，第二个人在 (j, k - j)处的所有走法的最大分值。
状态计算：按照最后一步两个人的走法分成四种情况：
两个人同时向右走，最大分值是 f[k - 1, i, j] + score(k, i, j)；
第一个人向右走，第二个人向下走，最大分值是 f[k - 1, i, j - 1] + score(k, i, j)；
第一个人向下走，第二个人向右走，最大分值是 f[k - 1, i - 1, j] + score(k, i, j)；
两个人同时向下走，最大分值是 f[k - 1, i - 1, j - 1] + score(k, i, j)；
注意两个人不能走到相同格子，即i和j不能相等。
作者：yxc
链接：https://www.acwing.com/solution/content/3954/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
cin>>g[i][j];
for(int k=2;k<=n+m;k++)
for(int i=max(1,k-m);i<=n&&i<k;i++)
for(int j=max(1,k-m);j<=n&&j<k;j++)
for(int a=0;a<=1;a++)
for(int b=0;b<=1;b++)
{
int t=g[i][k-i];
if(i!=j||k==2||k==n+m)
{
t+=g[j][k-j];
f[k][i][j]=max(f[k][i][j],f[k-1][i-a][j-b]+t);
}
}
cout<<f[n+m][n][n];
return 0;
}
//注意代码要放在两组三个点之间，才可以正确显示代码高亮哦~
作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4037889/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。二、LIS
Acwing 1012.友好城市
分析：取两对友好城市，假设x1<x2，要使得不相交，则需要y1<y2。题目要求则转化为，求最多对同时满足x1<x2,y1<y2的方案。若友好城市按x递增排序，则转化为求y数组的LIS。
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N =5010;
typedef pair<int,int> PII;
PII city[N];
int f[N];
int n;
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
int x,y;
cin>>x>>y;
city[i]={x,y};
}
sort(city,city+n);
int res=0;
for(int i=0;i<n;i++)
{
f[i]=1;
for(int j=0;j<i;j++)
if(city[i].second>city[j].second)
f[i]=max(f[i],f[j]+1);
res=max(res,f[i]);
}
cout<<res;
return 0;
}
作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4038147/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。Acwing 1010.拦截导弹
与贪心结合：遇到一个导弹时，由拦截高度比导弹高的系统中，高度最低的拦截。若拦截不了，就用新的系统拦截。
证明：若某一步贪心解与最优解不同，则最后，两段能够交换，不会产生新的系统。
#include<iostream>
#include<algorithm>
using namespace std;
const int N =1e5+10;
int f[N],g[N];
int n;
int a[N];
int main()
{
while(cin>>a[n]) n++;
int len=0;
f[0]=-2e9;
for(int i=0;i<n;i++)
{
int l=0,r=len;
while(l<r)
{
int mid=l+r+1>>1;
if(f[mid]>=a[i]) l=mid;
else r=mid-1;
}
len=max(len,r+1);
f[r+1]=a[i];
}
cout<<len<<endl;
int res=0;
int cnt=0;
for(int i=0;i<n;i++)
{
int k=0;
while(k<cnt&&g[k]<a[i]) k++;
g[k]=a[i];
if(k>=cnt) cnt++;
}
cout<<cnt;
}
作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4043034/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。Acwing 187.导弹拦截系统
贪心原理与上题相同，但是本次我们并不能判断是加入下降子序列中还是上升子序列中。解决方法是直接爆搜。需注意本题爆搜代码的编写
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
//思路同上一题 但由于不知道放入上升或下降系统中，因此直接爆搜求得答案
const int N =55;
int n;
int up[N],down[N];
int q[N];
int ans;
void dfs(int u,int su,int sd)//位置，当前上升子序列数量、下降子序列数量
{
if(su+sd>=ans) return; //这个分支不可能更新答案
if(u==n)
{
ans=su+sd;
return;
}
//情况1 加到上升子序列中
int k=0;
while(k<su&&up[k]>=q[u]) k++;//严格单调 因此>=
int t=up[k];
up[k]=q[u];
if(k<su) dfs(u+1,su,sd);
else dfs(u+1,su+1,sd);
up[k]=t; //恢复现场
//情况2 加入下降子序列中
k=0;
while(k<sd&&down[k]<=q[u]) k++;
t=down[k];
down[k]=q[u];
if(k<sd) dfs(u+1,su,sd);
else dfs(u+1,su,sd+1);
down[k]=t;
}
int main()
{
while(cin>>n,n)
{
for(int i=0;i<n;i++)
cin>>q[i];
ans=n;
dfs(0,0,0);
cout<<ans<<endl;
}
}Acwing 272.最长公共上升子序列
结合LIS和LCS，用f[i,j]表示a序列中前i个数字选择，以bj结尾的最长公共上升子序列。
状态划分f[i,j]：
- 若不选择ai，则为f[i-1,j]
- 若选择ai。要计算该情况则需要再细分，细分为结尾是b1~bj-1的最长公共上升子序列（为保证上升，需要bk<bj才能加入决策集合），即：
则循环体朴素写法为：
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
f[i][j]=f[i-1][j];
if(a[i]==b[j])
{
f[i][j]=max(f[i][j],1);
for(int k=1;k<j;k++)
{
if(b[k]<b[j]) //等价于b[k]<a[i]
f[i][j]=max(f[i][j],f[i][k]+1);
}
}
}
注意到第二层与第三层循环可以合并。
把0<=k<j,b[k]<a[i] 的k构成的集合称为f[i,j]转移时的决策集合；
注意到在第二层循环j增加到m时，第一层循环i是个定值，即b[k]<a[i]是固定的。因此j增加1时，k的取值范围从0~j变为0~j+1，，即j可能进入新的决策集合。
也就是说只需要检查b[j]<a[i]是否成立，已经在决策集合中的数则一定不会去除。
简单解释：保存符合条件的f[i,k]的最大值maxv。j即将增大时，判断b[j]<a[i]，若成立则f[i-1][j]也可能在决策集合里。即maxv=max(maxv,f[i-1][j])。
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N =3010;
int n;
int a[N],b[N],f[N][N];
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
for(int i=1;i<=n;i++) cin>>b[i];
/*for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
f[i][j]=f[i-1][j];
if(a[i]==b[j])
{
f[i][j]=max(f[i][j],1);
for(int k=1;k<j;k++)
{
if(b[k]<b[j]) //等价于b[k]<a[i]
f[i][j]=max(f[i][j],f[i][k]+1);
}
}
}
*/
//把0<=k<j,b[k]<a[i] 的k构成的集合称为f[i,j]转移时的决策集合
//注意到在第二层循环j增加到m时，第一层循环i是个定值，即b[k]<a[i]是固定的。
//因此j增加1时，k的取值范围从0~j变为0~j+1，，即j可能进入新的决策集合。
//也就是说只需要检查b[j]<a[i]是否成立，已经在决策集合中的数则一定不会去除。
//简单解释：保存符合条件的f[i,k]的最大值maxv。
//j即将增大时，判断b[j]<a[i]，若成立则f[i-1][j]也可能在决策集合里。即maxv=max(maxv,f[i-1][j])
for(int i=1;i<=n;i++)
{
//val是决策集合中f[i,k]的最大值
int val=0;
//j==1时，0可以作为k的取值
if(b[0]<a[i]) val=f[i-1][0];
for(int j=1;j<=n;j++)
{
if(a[i]==b[j]) f[i][j]=val+1;
else f[i][j]=f[i-1][j];
if(b[j]<a[i]) val=max(val,f[i][j]);
}
}
int res=0;
for(int i=1;i<=n;i++) res=max(res,f[n][i]);
cout<<res;
return 0;
}
5284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
