动态规划（1）LIS,LCS,数字三角形模型

 一、数字三角形

 

Acwing1027 方格取数

 思路：可以走两次，也可以同时走两条路，本次采用同时走的方式

令k为走的步数，即k==i1+j1=i2+j2。表示从两条路从（1,1）走到（i1，j1）（i2，j2）的最大值

状态划分为最后一步，两个点分别向右、上移动（2^2），共四种情况。

由于走过之后数被取走，因此取数时如果两个点重合了（i2==i1），则t只加一次。

#include
#include
#include
//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<

Acwing275.传纸条

 总结：类似方格取数，不过严格要求不能走到同一个点，走过某个点之后数不会被取走。

//这里填你的代码^^
#include
#include
#include
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

二、LIS

Acwing 1012.友好城市

 分析：取两对友好城市，假设x1

#include
#include
#include
using namespace std;

const int N =5010;
typedef pair PII;

PII city[N];
int f[N];
int n;

int main()
{
    cin>>n;
    for(int i=0;i>x>>y;
        city[i]={x,y};
    }

    sort(city,city+n);

    int res=0;

    for(int i=0;icity[j].second)
                f[i]=max(f[i],f[j]+1);
        res=max(res,f[i]);
    }
    cout<

Acwing 1010.拦截导弹

与贪心结合：遇到一个导弹时，由拦截高度比导弹高的系统中，高度最低的拦截。若拦截不了，就用新的系统拦截。

证明：若某一步贪心解与最优解不同，则最后，两段能够交换，不会产生新的系统。

#include
#include
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>1;
            if(f[mid]>=a[i]) l=mid;
            else r=mid-1;
        }
        len=max(len,r+1);
        f[r+1]=a[i];
    }
    cout<=cnt) cnt++;
    }
    cout<

Acwing 187.导弹拦截系统

 贪心原理与上题相同，但是本次我们并不能判断是加入下降子序列中还是上升子序列中。解决方法是直接爆搜。需注意本题爆搜代码的编写

#include
#include
#include
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=q[u]) k++;//严格单调 因此>=
    int t=up[k];
    up[k]=q[u];
    if(k>n,n)
    {
        for(int i=0;i>q[i];
        
        ans=n;
        
        dfs(0,0,0);
        cout<

Acwing 272.最长公共上升子序列

 结合LIS和LCS，用f[i,j]表示a序列中前i个数字选择，以bj结尾的最长公共上升子序列。

状态划分f[i,j]：

• 若不选择ai，则为f[i-1,j]
• 若选择ai。要计算该情况则需要再细分，细分为结尾是b1~bj-1的最长公共上升子序列（为保证上升，需要bk

则循环体朴素写法为：

    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

注意到第二层与第三层循环可以合并。

把0<=k

注意到在第二层循环j增加到m时，第一层循环i是个定值，即b[k]

也就是说只需要检查b[j]

简单解释：保存符合条件的f[i,k]的最大值maxv。j即将增大时，判断b[j]

#include
#include
#include
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