dp训练

根据这位大佬的https://www.cnblogs.com/Bunnycxk/p/7360183.html

题目链接；https://www.luogu.org/problemnew/show/P3399

题目描述

小仓鼠带着货物，从中国送到安息，丝绸之路包括起点和终点一共有N+1个城市，0号城市是起点长安，N号城市是终点巴格达。要求不超过M天内必须到达终点。一天的时间可以从一个城市到连续的下一个城市。从i-1城市到i城市距离是Di。

大家都知道，连续赶路是很辛苦的，所以小仓鼠可以在一个城市时，可以有以下选择：

• 移动：向下一个城市进发

• 休息：呆在原来的城市不动

沙漠天气变化无常，在天气很不好时，前进会遇到很多困难。我们把M天的第j(1<=j<=M)天的气候恶劣值记为Cj。从i-1城市移动到i城市在第j天进发时，需要耗费Di*Cj的疲劳度。

不过小仓鼠还是有选择权的，可以避开比较恶劣的天气，休息是不会消耗疲劳值的。现在他想知道整个行程最少要消耗多少疲劳值。

输入输出格式

输入格式：

第一行2个整数N，M

连续N行每行一个整数Dj

连续M行每行一个整数Cj

输出格式：

一个整数，表示最小疲劳度

输入输出样例

输入样例#1： 复制

3 5
10
25
15
50
30
15
40
30

输出样例#1： 复制

1125

#include <stdio.h>
#include<iostream>
#include <string.h>
#include <vector>
using namespace std;
#define N 1000
vector<int> d;
vector<int> c;
int f[N][N];
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        int temp;
        d.push_back();
        c.push_back();//因为后边需要的是从下标1开始
        for(int i=;i<n;i++){
            scanf("%d",&temp);
            d.push_back(temp);
        }
        for(int j=;j<m;j++){
            scanf("%d",&temp);
            c.push_back(temp);
        }//读入。
        //初始化，一天都不歇,
        //f[1][0]=0;

        for(int i=;i<=n;i++)
             f[][i]=;
//        f[1][1]=d[0]*c[0];
//        for(int i=2;i<=n;i++){
//            f[i][i]=f[i-1][i-1]+d[i]*c[i];
//        }
//        int j=0;//从第0天开始
//        for(int i=1;i<=n;i++){
//            if(f[i][j-1]>f[i-1][j-1]+d[i]*c[j]){
//                f[i][j]=f[i-1][j-1]+d[i]*c[j];
//                j++;
//            }else{
//                f[i][j]=f[i][j-1];//也就是说第j天，依旧是在i城市，
//            }不能这样初始化，因为每一个是和之前的相关的
//        }
        for(int i=;i<=n;i++){
            f[i][i]=f[i-][i-]+c[i]*d[i];//如果一直走；第i天，到了i城市。
            for(int j=i+;j<=m;j++){//如果延迟了
                f[i][j]=min(f[i][j-],f[i-][j-]+c[j]*d[i]);
            }
        }//f[i][..]是就算当前是乘以最后一天m疲惫值最小，那也需要结合f[i+1][..]天的情况决定到底是选f[i][几]的。
        //也就是说 从这f[i][..]里选择一个更小的。
        printf("%d",f[n][m]);
    }//两个疑问，
    //一个是完全就不用走所花匹配值最小。。第二如果天数不够用是怎么控制的?
    return ;
}

//动态二维dp,关键还是状态函数，感觉有点难理解。经常复习一下吧

2.在一个给定的单词表中取出一些词，组成最长的词链，就是包含单词数最多的词链。将它的单词数统计出来，就得到密码了。密码就是最长词链所包括的单词数。

输入输出样例

输入样例#1： 复制

5
i
int
integer
intern
internet

输出样例#1： 复制

4
//看见这个就完全看不懂的感觉。就想到暴力破解，循环，

#include<iostream>
#include<string>
using namespace std;
string s[];
int wz[],n;
int main()
{
    cin>>n;
    for(int i=;i<=n;i++) {
        cin>>s[i];
        wz[i]=;
        for(int j=i-;j>=;j--)
        if(s[i].find(s[j])==)//起始位置是否为0
            wz[i]=(wz[j]+)>wz[i]?(wz[j]+):wz[i];
        wz[]=wz[i]>wz[]?wz[i]:wz[];//顺便用它来保存
    }
    cout<<wz[];
    return ;
}

//真的是很神奇，直接用find就可以了，输入一个那么就find之前的所有数，是否是返回0，即从0位置开始，厉害。来自题解，链接：https://www.luogu.org/problemnew/solution/P1481

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=;
struct edge
{
    int link[];//每个都有26个字母
    int s;//以当前字母结尾的串的个数
} t[MAXN];
int n,m,cnt;
int ans;
void zbr(char *c)//建立字典树的过程。
{
    int ansm=;
    int p=;
    int i;
    int len=strlen(c);
    for(int i=; i<len; i++)
    {
        int zz=c[i]-'a'+;
        if(t[p].link[zz]==)
            t[p].link[zz]=++cnt;//cnt表示的是下标，即t数组中，用到第几个了。
        p=t[p].link[zz];
        ansm+=t[p].s;
    }

    if(ansm>=ans)
        ans=ansm+;
    t[p].s++;//在结尾的时候才++
}
int main()
{
    int i;
    char c[]="";
    scanf("%d",&n);
    for(int i=; i<=n; i++)
    {
        scanf("%s",c);
        zbr(c);
    }
    printf("%d\n",ans);
    return ;
}

//这个是用字典树写的，不太理解什么意思。

南大2018夏令营机试dp

转自：https://mp.weixin.qq.com/s/WLRXLdi-3igkjtiWlHg7Ug

1. Count number of binary strings without consecutive 1's

Given a positive integer n(3≤n≤90), count all possible distinct binary strings of length n such that there are no consecutive 1's .

Examples:

Input:  2
Output: 3 // The 3 strings are 00, 01, 10 

Input: 3
Output: 5 // The 5 strings are 000, 001, 010, 100, 101

主要思想：令a[i]为长度为i的不含连续1的二进制串的个数，考虑长度为i的不含连续1的任意一个二进制串：若第i位（末位）为0，则第i-1位可以为0也可以为1，这种情况的二进制串有a[i-1]个；若第i位为1，则第i-1位只能为0（否则最后两位为连续两个1，不符题意），进一步考虑第i-2位，由第i-1位为0可知第i-2位可以为0也可以为1，这种情况的二进制串有a[i-2]个。综上可以写出递推式 a[i]=a[i-1]+a[i-2], i≥3，边界条件为a[1]=1,a[2]=3。本题动态规划的时间复杂度为O(n)。

#include<iostream>
using namespace std;
int main() {
    int n;
    cin>>n;
    long long *a = new long long[n+]{,,};
    for(int i=;i<=n;i++) {
        a[i]=a[i-]+a[i-];
    }
    cout<<a[n]<<endl;
    return ;
}

//看完之后就觉得太厉害了！学习了！还需要不断学习！