状态dp若干入门题

最新推荐文章于 2022-03-29 12:17:03 发布
最新推荐文章于 2022-03-29 12:17:03 发布
阅读量1k 收藏 1
点赞数
分类专栏： DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiyuankongbu/article/details/9715709
版权

 1. hdu 1565 方格取数(1)

状态dp

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
int legal[1<<20];
int num,a[21][21];
int dp[21][1<<20];
int n;
void init()
{
    num=0;
    for(int i=0;i<(1<<n);i++)
    {
        if(i&(i<<1) || i&(i>>1))
            continue;
        legal[++num]=i;
    }
}
int get(int i,int j) // 第i行第j种状态下，本行可获取的值
{
    int ans=0;
    int tmp=legal[j];
    int k=n;
    while(tmp)
    {
        if(tmp&1)
            ans+=a[i][k];
        k--;
        tmp/=2;
    }
    return ans;
}
int main()
{
    init();
    while(scanf("%d",&n)!=EOF)
    {
        init();
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                scanf("%d",&a[i][j]);
        for(int i=1;i<=n;i++)
            a[0][i]=0;
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=num;j++)
            {
                int tmp=-0xfffffff;
                for(int k=1;k<=num;k++)
                {
                    if(legal[j]&legal[k])
                        continue;
                    tmp=max(tmp,dp[i-1][k]);
                }
                dp[i][j]=tmp+get(i,j);
                ans=max(ans,dp[i][j]);
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}


2. poj 3254 Corn Fields

状态dp

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int mod=(1e8);
int dp[13][1<<12];
int legal[1<<12];
int num,pos[13];
int m,n;
void init()
{
    num=0;
    for(int i=0;i<(1<<n);i++)
    {
        if(i&(i<<1) || i&(i>>1))
            continue;
        legal[++num]=i;
    }
}
int main()
{
    int x;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        init();
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=m;i++)
        {
            pos[i]=0;
            for(int j=1;j<=n;j++)
            {
                scanf("%d",&x);
                if(x==0)
                    pos[i]|=1<<(n-j);
            }
        }
        for(int i=1;i<=num;i++)
        {
            if(legal[i]&pos[1])
                continue;
            dp[1][i]=1;
        }
        for(int i=2;i<=m;i++)
            for(int j=1;j<=num;j++)
            {
                if(pos[i]&legal[j])
                    continue;
                for(int k=1;k<=num;k++)
                {
                    if(pos[i-1]&legal[k])
                        continue;
                    if(legal[j]&legal[k])
                        continue;
                    dp[i][j]+=dp[i-1][k];
                    dp[i][j]%=mod;
                }
            }
        int ans=0;
        for(int i=1;i<=num;i++)
            ans=(ans+dp[m][i])%mod;
        printf("%d\n",ans);
    }
    return 0;
}


3. poj 1185 炮兵阵地

状态dp

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
int legal[61];
int dp[101][61][61];
int pos[101];
int a[101][11];
int num,n,m;
void init()
{
    num=0;
    for(int i=0;i<(1<<m);i++)
        if( i&(i<<1) || i&(i<<2) || i&(i>>1) || i&(i>>2))
            continue;
        else
            legal[++num]=i;
}
int get(int i,int j)
{
    int ans=0;
    int tmp=legal[j];
    int k=m;
    while(tmp)
    {
        if(tmp&1)
            ans+=a[i][k];
        k--;
        tmp/=2;
    }
    return ans;
}
int main()
{
    char s;
    scanf("%d%d",&n,&m);
    getchar();
    init();
    memset(a,0,sizeof(a));
    memset(dp[1],0,sizeof(dp[1]));
    for(int i=1;i<=n;i++)
    {
        pos[i]=0;
        for(int j=1;j<=m;j++)
        {
            scanf("%c",&s);
            if(s=='H')
            {
                pos[i]|=1<<(m-j);
            }
            else
                a[i][j]=1;
        }
        getchar();
    }
    int ans=0;
    /// dp[i][j][k] 表示当前第i行状态为j,第i-1行状态为k的方案数
    //预处理第一行
    for(int i=1;i<=num;i++)
    {
        if(pos[1]&legal[i])
            continue;
        dp[1][i][1]=get(1,i);
        ans=max(ans,dp[1][i][1]);
    }
    // 预处理第二行
    for(int i=1;i<=num;i++)
    {
        if(pos[2]&legal[i])
            continue;
        for(int j=1;j<=num;j++)
        {
            if(pos[1]&legal[j])
                continue;
            if(legal[i]&legal[j])
                continue;
            dp[2][i][j]=dp[1][j][1]+get(2,i);
            ans=max(ans,dp[2][i][j]);
        }
    }
    for(int i=3;i<=n;i++)
    {
        for(int j=1;j<=num;j++) // 当前行的状态
        {
            if(pos[i]&legal[j])
                continue;
            for(int k=1;k<=num;k++) // 前一行的状态
            {
                if(legal[j]&legal[k])
                    continue;
                if(pos[i-1]&legal[k])
                    continue;
                int tmp=-1;
                for(int l=1;l<=num;l++)
                {
                    if(legal[l]&pos[i-2])
                        continue;
                    if(legal[l]&legal[k])
                        continue;
                    if(legal[l]&legal[j])
                        continue;
                    tmp=max(tmp,dp[i-1][k][l]);
                }
                dp[i][j][k]=tmp+get(i,j);
                ans=max(ans,dp[i][j][k]);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}




4.light oj 1244 - Tiles

状态压缩，矩阵加速

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
#define mod 10007
struct Matrix
{
    long long m[5][5];
}E,D,T;
void init()
{
    for(int i=1;i<=4;i++)
        for(int j=1;j<=4;j++)
        {
            E.m[i][j]=(i==j);
            D.m[i][j]=0;
        }
    for(int i=1;i<=4;i++)
        D.m[1][i]=1;
    D.m[2][1]=1;
    D.m[3][2]=D.m[3][4]=1;
    D.m[4][2]=D.m[4][3]=1;
    T.m[1][1]=T.m[2][1]=1;
    T.m[3][1]=T.m[4][1]=0;
}
Matrix Multi(Matrix A,Matrix B)
{
    Matrix ans;
    for(int i=1;i<=4;i++)
        for(int j=1;j<=4;j++)
        {
            ans.m[i][j]=0;
            for(int k=1;k<=4;k++)
                ans.m[i][j]=(ans.m[i][j]+A.m[i][k]*B.m[k][j])%mod;
        }
    return ans;
}
Matrix Pow(Matrix A,long long k)
{
    Matrix ans=E;
    while(k)
    {
        if(k&1)
        {
            k--;
            ans=Multi(ans,A);
        }
        else
        {
            k/=2;
            A=Multi(A,A);
        }
    }
    return ans;
}
int main()
{
    int t;
    long long n;
    scanf("%d",&t);
    init();
    for(int cases=1;cases<=t;cases++)
    {
        scanf("%lld",&n);
        Matrix ans=Pow(D,n-1);
        ans=Multi(ans,T);
        printf("Case %d: %lld\n",cases,ans.m[1][1]);
    }
    return 0;
}



5. Tri Tiling

状态dp

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
long long dp[31][8];
int main()
{
    memset(dp,0,sizeof(dp));
    dp[0][0]=1;
    for(int i=1;i<=30;i++)
    {
        dp[i][0]=dp[i-1][1]+dp[i-1][4]+dp[i-1][7];
        dp[i][1]=dp[i-1][6]+dp[i-1][0];
        dp[i][2]=dp[i-1][5];
        dp[i][3]=dp[i-1][4];
        dp[i][4]=dp[i-1][0]+dp[i-1][3];
        dp[i][5]=dp[i-1][2];
        dp[i][6]=dp[i-1][1];
        dp[i][7]=dp[i-1][0];
    }
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n<0)
            break;
        printf("%lld\n",dp[n][0]);
    }
    return 0;
}



6. poj 2411 Mondriaan's Dream

棋盘覆盖

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;
LL dp[12][1<<11];
// 设横着放的为11，竖着放的01
// 那么对于每行，一定不存在连续奇数的1
// 每两行不存在竖行连续为00
int m,n,mx;
bool ok1(int i)
{
    //
    int bits=0;
    while(i)
    {
        if(i&1)
            bits++;
        else
        {
            if(bits&1)
                return false;
            bits=0;
        }
        i/=2;
    }
    if(bits&1)
        return false;
    return true;
}
bool ok2(int a,int b)
{
    if((a|b)!=mx)
        return false;
    return ok1(a&b);
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(m==n&&m==0)
            break;
        if((m*n)&1)
            printf("0\n");
        else
        {
            if(m<n)
                swap(m,n);
            mx=(1<<m)-1;
            memset(dp,0,sizeof(dp));
            for(int i=0;i<(1<<m);i++)
                if(ok1(i))
                    dp[1][i]=1;
            for(int i=2;i<=n;i++)
                for(int j=0;j<(1<<m);j++)
                    for(int k=0;k<(1<<m);k++)
                        if(ok2(j,k))
                            dp[i][j]+=dp[i-1][k];
            printf("%I64d\n",dp[n][(1<<m)-1]);
        }
    }
    return 0;
}


7. hdu 4539 郑厂长系列故事——排兵布阵

跟炮兵阵地一样，为了节省内存，用了滚动数组（上次看小萌用了这个）。

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
int legal[170];
int dp[2][170][170];
int a[101][11];
int num,n,m;
int pos[101];
void init()
{
    num=0;
    for(int i=0;i<(1<<m);i++)
    {
        if(i&(i<<2) || i&(i>>2))
            continue;
        legal[++num]=i;
    }
}
int get(int i,int j)
{
    int tmp=legal[j];
    int k=m;
    int ans=0;
    while(tmp)
    {
        if(tmp&1)
        {
            ans+=a[i][k];
        }
        k--;
        tmp/=2;
    }
    return ans;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        memset(a,0,sizeof(a));
        //cout<<num<<endl;
        for(int i=1;i<=n;i++)
        {
            pos[i]=0;
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&a[i][j]);
                if(a[i][j]==0)
                    pos[i]|=(1<<(m-j));
            }
            //cout<<pos[i]<<endl;
        }
        int ans=0;
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=num;i++)
        {
            if(pos[1]&legal[i])
                continue;
            dp[1][i][1]=get(1,i);
            ans=max(ans,dp[1][i][1]);
        }
        memcpy(dp[0],dp[1],sizeof(dp[1]));
        memset(dp[1],0,sizeof(dp[1]));
        for(int i=1;i<=num;i++)
        {
            if(pos[2]&legal[i])
                continue;
            for(int j=1;j<=num;j++)
            {
                if(pos[1]&legal[j])
                    continue;
                if((legal[j]<<1)&legal[i] || (legal[i]<<1)&legal[j])
                    continue;
                dp[1][i][j]=dp[0][j][1]+get(2,i);
                ans=max(ans,dp[1][i][j]);
            }
        }
        for(int i=3;i<=n;i++)
        {
            memcpy(dp[0],dp[1],sizeof(dp[0]));
            memset(dp[1],0,sizeof(dp[1]));
            for(int j=1;j<=num;j++)
            {
                if(pos[i]&legal[j])
                    continue;
                for(int k=1;k<=num;k++)
                {
                    if(legal[k]&pos[i-1])
                        continue;
                    if((legal[j]<<1)&legal[k] || (legal[k]<<1)&legal[j])
                        continue;
                    int tmp=-1;
                    for(int l=1;l<=num;l++)
                    {
                        if(legal[l]&pos[i-2])
                            continue;
                        if(legal[l]&legal[j])
                            continue;
                        if((legal[l]<<1)&legal[k] || (legal[k]<<1)&legal[l])
                            continue;
                        tmp=max(tmp,dp[0][k][l]);
                    }
                    dp[1][j][k]=tmp+get(i,j);
                    ans=max(ans,dp[1][j][k]);
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}


8. nyoj 492 King

状态dp

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
int legal[150];
long long dp[2][150][101];
int num;
int n,k;
void init()
{
    num=0;
    for(int i=0;i<(1<<n);i++)
    {
        if(i&(i<<1) || i&(i>>1))
            continue;
        legal[++num]=i;
    }
}
int get(int i)
{
    int tmp=legal[i];
    int ans=0;
    while(tmp)
    {
        if(tmp&1)
            ans++;
        tmp/=2;
    }
    return ans;
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        init();
        //cout<<num<<endl;
        memset(dp,0,sizeof(dp));
        dp[1][1][0]=1;
        for(int i=1;i<=n;i++)
        {
            memcpy(dp[0],dp[1],sizeof(dp[0]));
            memset(dp[1],0,sizeof(dp[1]));
            for(int j=1;j<=num;j++)
            {
                for(int l=get(j);l<=k;l++)
                {
                    for(int p=1;p<=num;p++)
                    {
                        if(legal[p]&legal[j])
                            continue;
                        if((legal[p]<<1)&legal[j])
                            continue;
                        if((legal[p]>>1)&legal[j])
                            continue;
                        dp[1][j][l]+=dp[0][p][l-get(j)];
                    }
                }
            }
        }
        long long ans=0;
        for(int i=1;i<=num;i++)
            ans+=dp[1][i][k];
        printf("%lld\n",ans);
    }
    return 0;
}


9. poj 3311 Hie with the Pie

floyd + 状态dp

#include <cstdio>  
#include <cstring>  
#include <iostream>  
#include <cmath>  
#include <algorithm>  
using namespace std;  
int dp[1<<11][12];  
int cnt[12][12];  
int main()  
{  
    int n;  
    while(scanf("%d",&n),n!=0)  
    {  
        for(int i=0;i<=n;i++)  
            for(int j=0;j<=n;j++)  
                scanf("%d",&cnt[i][j]);  
        for(int k=0;k<=n;k++)
            for(int i=0;i<=n;i++)  
                for(int j=0;j<=n;j++)  
                    cnt[i][j]=min(cnt[i][j],cnt[i][k]+cnt[k][j]);  
        memset(dp,0x3f,sizeof(dp));  
        int ans=dp[0][0];  
        for(int state=0;state<(1<<n);state++)  
        {  
            for(int i=1;i<=n;i++)  
            {  
                if(state&(1<<(i-1)))  
                {  
                    if(state==(1<<(i-1)))  
                    {  
                        dp[state][i]=cnt[0][i];  
                        continue;  
                    }  
                    for(int j=1;j<=n;j++)  
                    {  
                        if(i==j)  
                            continue;  
                        if((1<<(j-1))&state)  
                            dp[state][i]=min(dp[state][i],dp[state&~(1<<(i-1))][j]+cnt[j][i]);  
                    }  
                }  
            }  
        }  
        for(int i=1;i<=n;i++)  
            ans=min(ans,dp[(1<<n)-1][i]+cnt[i][0]);  
        printf("%d\n",ans);  
    }  
    return 0;  
}



或者用全排列水过 

#include <cstdio>  
#include <cstring>  
#include <iostream>  
#include <cmath>  
#include <algorithm>  
using namespace std;  
int cnt[12][12];  
int path[12];  
int main()  
{  
    int n;  
    while(scanf("%d",&n),n!=0)  
    {  
        for(int i=0;i<=n;i++)  
            for(int j=0;j<=n;j++)  
                scanf("%d",&cnt[i][j]);  
        for(int k=0;k<=n;k++)
            for(int i=0;i<=n;i++)  
                for(int j=0;j<=n;j++)  
                    cnt[i][j]=min(cnt[i][j],cnt[i][k]+cnt[k][j]);  
        for(int i=1;i<=n;i++)  
            path[i]=i;  
        int ans=0x7fffffff;  
        int tmp;  
        do  
        {  
            tmp=cnt[0][path[1]];  
            tmp+=cnt[path[n]][0];  
            for(int i=1;i<n;i++)  
                tmp+=cnt[path[i]][path[i+1]];  
            ans=min(ans,tmp);  
  
        }while(next_permutation(path+1,path+n+1));  
        printf("%d\n",ans);  
    }  
    return 0;  
}




shiyuankongbu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
状压DP 入门题
ww的博客
08-06 5328
一：方格取数 问题描述： Description 给你一个n*n的格子的棋盘，每个格子里面有一个非负数。 从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取的数所在的2个格子不能相邻，并且取出的数的和最大。 Input 包括多个测试实例，每个测试实例包括一个整数n 和n*n个非负数(n<=20) Output 对于每个测试实例，输出可能取得的最大的和 Sample
c语言dp状态转移方程,[总结-动态规划]经典DP状态设定和转移方程
weixin_42511201的博客
05-25 961
马上区域赛，发现DP太弱，赶紧复习补上。#普通DPCodeForces-546D Soldier and Number Game 筛法+动态规划待补UVALive-8078 Bracket Sequence问以每个字符为左端点的最长括号序列是多长。(包括尖、花、中小括号)状态：设dp[i]为从i开始的括号序列最长长度。转移：以i+1为起点的最长串后边的字符若与左括号匹配，答案是加上这个字符后边的最...
动态规划之状态压缩dp入门
热门推荐
qxAi的博客
02-04 5万+
状态压缩动态规划（简称状压dp）是另一类非常典型的动态规划，通常使用在NP问题的小规模求解中，虽然是指数级别的复杂度，但速度比搜索快，其思想非常值得借鉴。 为了更好的理解状压dp，首先介绍位运算相关的知识。 1.’&’符号，x&y，会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。例如3(11)&2(10)=2(10)。 2.’|’符号，x|y，会将两个十进制数在二进制下进行或运
dp和状态压缩dp的入门
weixin_51737895的博客
03-29 966
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 做题做到状态压缩dp真的看不懂答案了，从b站找了两个课听，受益匪浅，做了笔记。 一、DP入门 核心：从集合角度分析dp问题，经验也重要 有限级的最优化：从定义求：枚举太难 DP优化：1.化零为整（状态表示fi）a：集合 ...
状态压缩dp入门-蒙德里安的梦想
国家一级划水运动员的博客
11-08 98
题目描述 输入描述 输出描述 数据范围 输入样例 1 2 1 3 1 4 2 2 2 3 2 4 2 11 4 11 0 0 输出样例 1 0 1 2 3 5 144 51205 本题中，采用了先放横的小方块，再在空位插入竖的小方块的解法，此时总方案数即为只放横着小方块的合法方案数。原因在于：对于某种放置完横的小方块的情况后，插入竖的小方块的方法一定是唯一的。因此本题可转化为在按某种方法放置了横的小方块后，剩余空位是否满足能够插满若干竖的小方块，满足该情况的方法数总和即为总方案数。 由于竖小方
入门dp状态转移分析
人工智能方向，计算机视觉
06-10 370
斐波那契(Fibonacci)数列： F[n]=F[n-1]+F[n-2] (n>=3,F[1]=1,F[2]=1) #define fo(i,a,b) for(int i=a;i<b;i++) int Fi[20]; int F(int n){ if(n==0||n==1||n==2)return (Fi[n]=1); if(Fi[n]!=0) return Fi[n]; return (Fi[n]=F(n-1)+F(n-2)); } int main(){ c
状态压缩DP入门
keep coding
03-25 2060
原博地址：http://blog.csdn.net/u011077606/article/details/43487421  感谢分享状态压缩动态规划（简称状压dp）是另一类非常典型的动态规划，通常使用在NP问题的小规模求解中，虽然是指数级别的复杂度，但速度比搜索快，其思想非常值得借鉴。为了更好的理解状压dp，首先介绍位运算相关的知识。1.’&amp;’符号，x&amp;y，会将两个十进制数在二进...
状态压缩DP poj 2817 WordStack 入门题
Welcome To My Blog....
01-16 455
题目链接：  http://poj.org/problem?id=2817 题意： 给出n个字符串，一个排列使得相邻字符串之间的共同字母总数最多，这里的字母必须是一一对应的； 可以加空格。比如abc 和 asc，可以有很多种组合方式；如： abc      abc        abc          _abc   __abc         ___abc asc       _ asc
DP入门
qq_53737964的博客
02-25 1276
动态规划算法 他针对满足特定条件的一类问题，对各状态维度进行分阶段、有顺序、无重复、决策性的遍历求解。 dp入门，主要讲解dp里的几个经典的案例，通过案例来感受动态规划的主要思想 例题一：数字三角形 Description 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 （图一） 图一表示一个5行的数字三角形。假设给定一个n行数字三角形，计算出从三角形顶至底的一条路径，使该路径经过的数字总和最大。每一步只能由当前位置向左下或右下。 Input 你的程序要能接受标准输入。第一行包含一个整数T，表示
经典树型DP状态压缩DP入门
03-16
经典入门 - 树型动态规划和状态压缩动态规划 什么是树型动态规划： 树本身就是一个递归的结构，所以在树上进行动态规划或者递推是在合适不过的事情。 必要条件：子树之间不可以相互干扰，如果本来是相互干扰的，...
cf 1316E(贪心优化的状态压缩dp) 好题
01-03
题意： 给你n个人，从中选出p个球员和k个观众，第i个人作为观众产生价值ai，第i个人作为j号球员产生价值Ci,j ，求最大价值 (2≤n≤105,1≤p≤7,1≤k,p+k≤n,ai<109,ci,j<109) 输入 第1行输入n p k ...
Azure DP-203考试题
05-15
Azure DP-203的考试题，包括参考答案和答案解释，文档详细介绍
状态压缩DP
04-01
包含状态压缩DP的原理及经典例子，感兴趣的同学可以下载
FM 458-1DP 入门手册.pdf
06-05
FM 458-1DP 入门手册.pdf
dp46道~学习
shiyuan的专栏
02-22 3040
本来打算寒假的最后几天争取看能不能把dp46道给搞定的，结果发现过年的时候不想刷题，过完年之后大家又忙着去学校吃离别的饭了，于是嘛，计划又只是一个幌子 题目：来自 hdu  分类（我是看这儿的）：动态规划（46道题目） 目测开学之前是刷不完了，如果只是为了完成计划盲目的去做题，还不如不做，因为感觉那样的话，解决一个问题的本质就早已变了，如果是为了变强的话，在思维上进步就行了，做了多少多少题只
CF 159D Palindrome pairs
shiyuan的专栏
08-16 2299
题目：CF 159D  Palindrome pairs tag：dp 思路：枚举对称轴，用dpr[i]记录从0到位置i间回文串的个数，dpl[i]表示位置i到最后的回文串的个数。 需要求解的是形如回文串加回文串的种数，对于位置i,我们先累计前i个出现的回文串的个数乘上从i开始后面的回文串的个数，就是答案 #include #include #include #include
hdu 2639 （0-1背包第k优解）Bone Collector II
shiyuan的专栏
08-13 1847
Bone Collector II Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 821    Accepted Submission(s): 390 Problem Description The title of t
CF 2 B. The least round way
shiyuan的专栏
07-13 1656
题目：The least round way 思路：两次dp分别求2,5出现的幂的一条路径，如果这条路径上有0，那么最后的结果肯定是1（1个0），不然就是2和5的情况的最小的那种情况。 #include #include #include #include #include #define maxn 1010 #define inf 0xfffffff using names
tsp问题 dp状态压缩
最新发布
09-02
TSP（Traveling Salesman Problem）问题是一个经典的组合优化问题，旅行商问题...这样，状态压缩后的dp数组的大小为2^n * n，其中n表示城市的数量。 通过动态规划和状态压缩，可以有效地解决TSP问题，并找到最短路径。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值