简单DP

套题链接：https://vjudge.net/contest/152991#overview
A题–最少拦截系统：问题的实质就是求出最长的连续递增子序列的长度

#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 1000
using namespace std;
int n, a[maxn],d[maxn];

int main()
{
    while (~scanf("%d", &n))
    {
        for (int i = 0; i < n; i++) {
            scanf("%d", &a[i]);
            d[i] = 1;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (a[i] > a[j] && d[i] < d[j] + 1)
                    d[i] = d[j] + 1;
            }
        }
            int max = -1;
            for (int i = 0; i < n; i++)
                //printf("%d  ", d[i]);

                if (max < d[i])
                    max = d[i];
            printf("%d\n", max);
        }

    return 0;
}

B题-简单的最长连续子序列的和
动态转移方程：dp[i] = max{dp[i-1]+a[i],a[i]}

//HDU 1003-dp
//dp思想
#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 100010
using namespace std;
int a[maxn];

int main()
{
    int t;
    scanf("%d", &t);
    for (int l = 0; l < t; ++l) {
        int n;
        scanf("%d", &n);
        for (int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        int maxsum = -1000;
        int sum = 0;
        int head = 0;
        int tail = 0;
        int temp = 1;
        for (int i = 0; i < n; i++) {
            sum += a[i];
            if (sum > maxsum) {
                maxsum = sum;
                head = temp;
                tail = i + 1;
            }
            if (sum < 0) {
                sum = 0;
                temp = i + 2;
            }
        }
        printf("Case %d:\n", l+1);
        printf("%d %d %d\n", maxsum, head, tail);
        if (l != t-1)
            printf("\n");
    }
    return 0;
}

C题-变形的最长连续子序列的和
dp[j]表示前j个数，组成1组的和的最大值,再循环累加m次，即可得题目所求。
动态转移方程：dp[j] = max(dp[j - 1] + a[j], mmax[j - 1] + a[j]))

#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 1000000
#define INF 0x7fffffff
using namespace std;
int dp[maxn+10];
int mmax[maxn + 10];
int a[maxn + 10];
int main()
{
    int n,m;
    int i, j, mmmax;
    while (scanf("%d%d",&m,&n)!=EOF)
    {
        for (i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            mmax[i] = 0;
            dp[i] = 0;
        }
        dp[0] = 0;
        mmax[0] = 0;
        for (i = 1; i <= m; i++) {
            mmmax = -INF;
            for (j = i; j <= n; j++) {
                dp[j] = max(dp[j - 1] + a[j], mmax[j - 1] + a[j]);
                mmax[j - 1] = mmmax;
                mmmax = max(mmmax, dp[j]);
            }
        }
        printf("%d\n", mmmax);
    }
    return 0;
}

D题–双重条件的最长连续子序列的和

//dp思想
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<string.h>
#define maxn 100
#define INF 0x7fffffff
using namespace std;
int dp[maxn+10];//dp[i] = sum表示以第i个长方体为首层叠加起来高度最高为sum
struct node
{
    int l, w, h;
}box[maxn+10];
bool cmp(node a,node b)
{
    if (a.l > b.l) return true;
    if (a.l == b.l && a.w > b.w) return true;
    return false;
}
int main()
{
    int n,sumh;
    int d[3];
    int cases = 1;
    while (scanf("%d",&n),n)
    {
        int k = 0;
        memset(box, 0, sizeof(box));
        memset(dp, 0, sizeof(dp));

        for (int i = 0; i < n; i++) {
            scanf("%d %d %d", &d[0], &d[1], &d[2]);
            sort(d, d + 3);//这里要先对长宽高排序,让最小的和最大做为长和宽？？？还是没搞懂
            box[k].l = d[0]; box[k].w = d[1]; box[k].h = d[2]; k++;
            box[k].l = d[0]; box[k].w = d[2]; box[k].h = d[1]; k++;
            box[k].l = d[1]; box[k].w = d[2]; box[k].h = d[0]; k++;

        }
        //printf("before sort\n");
        //for (int i = 0; i < k; i++) printf("%d %d %d\n", box[i].l, box[i].w, box[i].h);
        sort(box, box + k, cmp);
        //printf("after sort box\n");
        //for (int i = 0; i < k; i++) printf("%d %d %d\n", box[i].l, box[i].w, box[i].h);
        for (int i = 0; i < k; i++)
            dp[i] = box[i].h;//初始化dp[i]为标号为第i个的原始高度
        for (int i = k - 2; i >= 0; i--)//为什么要从k-2开始呢：因为k-2到k属于一个长方体
            for (int j = i + 1; j < k; j++) {
                if (box[i].l > box[j].l && box[i].w>box[j].w)
                    if (dp[i] < dp[j] + box[i].h)
                        dp[i] = dp[j] + box[i].h;
            }
        sumh = dp[0];
        //printf("dp:1--k\n");
        //找出以这k个长方体叠加的最高高度sumh
        for (int i = 0; i < k; i++){
        //    printf("%d---%d ",i, dp[i]);
        //printf("\n");
            if (sumh < dp[i])
                sumh = dp[i];
        }
        printf("Case %d: maximum height = %d\n", cases++, sumh);
    }
    return 0;
}

E题-dfs+记忆化搜索
记忆化搜索就是：把第一次计算时的结果记录下来，省下第二次及以后重复计算的时间。
dp[i]=max表示从起始点走到i点最大值为max

#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 100
#define INF 0x7fffffff
using namespace std;
int n, k;
int dp[maxn+10][maxn+10];
//dp[i][j] = sum表示以第i个长方体为首层叠加起来高度最高为sum
int mpt[maxn + 10][maxn + 10];
int to[4][2]= { 1,0,-1,0,0,1,0,-1 };
int check(int x, int y) 
{
    if (x<1 || y<1 || x>n || y>n)
        return 1;
    return 0;
}
int dfs(int x,int y)
{
    int i, j, l, ans = 0;
    if (!dp[x][y])//没有走过
    {
        for (i = 1; i <= k; i++) {//可以走小于k以内的步数
            for (j = 0; j < 4; j++) {
                int xx = x + to[j][0] * i;
                int yy = y + to[j][1] * i;
                if (check(xx, yy)) continue;
                if (mpt[xx][yy] > mpt[x][y])
                    ans = max(ans, dfs(xx, yy));
            }
        }
        dp[x][y] = ans + mpt[x][y];
    }
    return dp[x][y];
}
int main()
{
    while (~scanf("%d%d", &n,&k) &&  n > 0 && k > 0)
    {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                scanf("%d", &mpt[i][j]);
        memset(dp, 0, sizeof(dp));
        printf("%d\n", dfs(1, 1));
    }
    return 0;
}

F题

#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 1000
#define INF 0x7fffffff
using namespace std;
struct node
{
    int w;//weight
    int s;//speed
    int n;//原来的位置
    int l;//上一只老鼠的位置
}a[maxn+10];
int n, k, dp[maxn + 10];//dp[i] = x最后一只老鼠位置为i，满足条件长度最长为x
bool cmp(node a, node b)
{
    if (a.w == b.w) return a.s < b.s;
    return a.w > b.w;
}
int main()
{
    int c = 1;
    int i, j;
    while (scanf("%d%d",&a[c].w, &a[c].s) != EOF)
    {
        a[c].n = c;
        a[c].l = 0;
        c++;
    }
    sort(a + 1, a + c + 1, cmp);
    a[0].w = INF;
    a[0].s = 0;
    a[0].n = 0;
    a[0].l = 0;
    int ans = 0;
    for (i = 1; i <= c; i++) {
        dp[i] = 0;
        for (j = 0; j < i; j++) {
            if (a[j].w > a[i].w && a[j].s < a[i].s) {
                if (dp[j] + 1 >= dp[i]) {
                    dp[i] = dp[j] + 1;
                    a[i].l = j;//记录上一只老鼠的位置
                    if (dp[i] > dp[ans])
                        ans = i;//记录最后一只老鼠的位置
                }
            }
        }
    }
    printf("%d\n", dp[ans]);//个数
    while (a[ans].l != 0)
    {
        printf("%d\n", a[ans].n);
        ans = a[ans].l;
    }
    printf("%d\n", a[ans].n);
    return 0;
}

G题
注意时间的表示

//状态转移方程是：dp[i] = min(dp[i-1]+单独买花的时间, dp[i-2]+和前面那个人一起买花的时间)

//初始状态是dp[1] = 第一个人单独买票的时间
#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 2000
#define INF 0x7fffffff
using namespace std;
int n, dp[maxn + 10], a[maxn+10], d[maxn+10];

int main()
{
    int T;
    int hh, mm, ss;
    scanf("%d", &T);
    while (T--)
    {
        memset(dp, 0, sizeof(dp));
        memset(a, 0, sizeof(a));
        memset(d, 0, sizeof(d));
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        for (int i = 2; i <= n; i++)
            scanf("%d", &d[i]);
        dp[1] = a[1];
        for (int i = 2; i <= n; i++)
            dp[i] = min(dp[i - 1] + a[i], dp[i - 2] + d[i]);
        hh = dp[n] / 3600;
        mm = (dp[n] / 60) % 60;
        ss = dp[n] % 60;
        printf("%02d:%02d:%02d%s\n", (8 + hh) %12, mm, ss, (hh + 8) % 12 > 12 ? " pm" : " am");
    }
    return 0;
}

H题-二维数组的dp

#include<stdio.h>
#include<algorithm>
#include<math.h>
#define maxn 2000
#define INF 0x7fffffff
using namespace std;
int n, dp[maxn + 10][maxn + 10], a[maxn+10];
bool cmp(int a, int b)
{
    return a < b;
}
int main()
{
    int n,k;
    while (~scanf("%d%d", &n, &k))
    {
        memset(dp, 0, sizeof(dp));
        memset(a, -1, sizeof(a));
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        sort(a + 1, a + n + 1, cmp);

        for (int j = 1; j <= k; j++) {
            for (int i = j * 2; i <= n; i++) {
                if (i == 2 * j)
                    dp[i][j] = dp[i - 2][j - 1] + (a[i - 1] - a[i])*(a[i - 1] - a[i]);
                else
                    dp[i][j] = min(dp[i - 1][j], dp[i - 2][j - 1] + (a[i - 1] - a[i])*(a[i - 1] - a[i]));
            }
        }
        printf("%d\n", dp[n][k]);
    }
    return 0;
}