Educational DP Contest

最新推荐文章于 2024-04-16 22:04:53 发布
最新推荐文章于 2024-04-16 22:04:53 发布
阅读量398 收藏 2
点赞数 1
分类专栏： 简单dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foolishpichao/article/details/107529645
版权

Educational DP Contest

A-Frog 1

题意:青蛙可以跳一格或者两格，跳到某格的花费是|hi−hj|；求最少的花费

public static void main(String[] args) {
    int N = sc.nextInt();
    int[] a = new int[N + 1],f = new int[N + 1];
    for(int i = 1; i <= N; i ++) a[i] = sc.nextInt();
    // 第一格的花销是0，故直接从2开始，
    for(int i = 2; i <= N; i++){
        if(i == 2)f[i] = f[i - 1] + Math.abs(a[i] - a[i - 1]);
        else f[i] = Math.min(Math.abs(a[i] - a[i - 1]) + f[i - 1],Math.abs(a[i] - a[i - 2]) + f[i - 2]);
    }
    System.out.println(f[N]);
}

B-Frog 2

题意:同上题，只是可以跳K格

static final int inf = 0x3f3f3f3f;
public static void main(String[] args) {
    int N = sc.nextInt(), k = sc.nextInt();
    int[] a = new int[N + 1],f = new int[N + 1];
    for(int i = 1; i <= N; i ++) a[i] = sc.nextInt();
    Arrays.fill(f,inf);
    f[1] = 0;

    // 注释掉的为 正跳，未注释的表示 当前位置从哪里来的递推
    for(int i = 2; i <= N; i++){
        for(int j = 1; j <= k; j ++){
            //                if(i + j <= N){
            //                    f[i + j] = Math.min(Math.abs(a[i] - a[i + j]) + f[i],f[i + j]);
            //                }else break;
            if(i > j){
                f[i] = Math.min(Math.abs(a[i] - a[i - j]) + f[i - j],f[i]);
                //                    else f[i] = Math.abs(a[i] - a[i - j]) + f[i - j];
            }else break;
        }
    }
    //        for(int i = 1; i <= N; i++) System.out.print(f[i] + " ");
    System.out.println(f[N]);
}

C-Vacation

题意：每天有三种选择，每种选择有一定的幸福值，连续两天不能选一样的，求最大的幸福值

递推，记录一下上一天的选择。

public static void main(String[] args) {
    int N = sc.nextInt();
    int[] a = new int[N  + 1], b = new int[N + 1], c = new int[N + 1];
    int[][] f = new int[N + 1][3];
    for(int i = 1; i <= N; i ++){
        a[i] = sc.nextInt();
        b[i] = sc.nextInt();
        c[i] = sc.nextInt();
    }
    // f[i][0] 表示当前选择 第 1 项运动。
    for(int i = 1; i <= N; i ++){
        f[i][0] = Math.max(f[i - 1][1],f[i - 1][2]) + a[i];
        f[i][1] = Math.max(f[i - 1][0],f[i - 1][2]) + b[i];
        f[i][2] = Math.max(f[i - 1][1],f[i - 1][0]) + c[i];
    }

    System.out.println(Math.max(Math.max(f[N][0],f[N][1]),f[N][2]));
}

D-Knapsack 1

题意: 单纯的0，1背包。

public static void main(String[] args) {
    int N = sc.nextInt(), W = sc.nextInt();
    int[] v = new int[N + 1], w = new int[N + 1];
    long[] f = new long[W  + 1];

    for(int i = 1; i <= N; i ++){
        v[i] = sc.nextInt();
        w[i] = sc.nextInt();
    }
    for(int i = 1; i <= N; i++){
        for(int j = W; j >= v[i]; j --){
            f[j] = Math.max(f[j],f[j - v[i]] + w[i]);
        }
    }
    System.out.println(f[W]);
}

E-Knapsack 2

题意：将0，1背包的体积变成10^9,故不可以直接枚举体积；

而其价值在1e3以内，故枚举价值，f[j] 代表，当前价值为 j的 最小重量；

static final int inf = 0x3f3f3f3f;
public static void main(String[] args) {
    int N = sc.nextInt(), W = sc.nextInt();
    int bound = 100 * 1000;
    int[] v = new int[N + 1], w = new int[N + 1];
    long[] f = new long[bound  + 1];
    Arrays.fill(f,inf);
    f[0] = 0;
    for(int i = 1; i <= N; i ++){
        v[i] = sc.nextInt();
        w[i] = sc.nextInt();
    }
    // f[j] 代表，当前价值为 j的 最小重量；
    for(int i = 1; i <= N; i++){
        for(int j = bound; j >= w[i]; j --){
            f[j] = Math.min(f[j],f[j - w[i]] + v[i]);
        }
    }
    int res = 0;
    for(int i = 0; i <= bound; i ++){
        // 如果 重量小于W 代表可以取，则价值为 i;
        if(f[i] <= W)res = i;
    }

    System.out.println(res);
}

F-LCS

题意:最长公共子序列

用last【】【】记录当前dp数组走的方向，方便逆推；

也可以直接判断，不需要last数组，详情见代码

public static void main(String[] args) {
    String s = sc.next(), t = sc.next();
    char[] s1 = s.toCharArray(), t1 = t.toCharArray();
    int[][] f = new int[s1.length + 1][t1.length + 1],last = new int[s1.length + 1][t1.length + 1];
    StringBuilder sb = new StringBuilder();
    // 第二种 回溯，可以借助一个数组，标记 dp的方向；
    for(int i = 1; i <= s1.length; i ++) {
        for (int j = 1; j <= t1.length; j++) {
            if (s1[i - 1] == t1[j - 1]) {
                f[i][j] = f[i - 1][j - 1] + 1;
                last[i][j] = 3; // 记录方向 左上角
            } else {
                if (f[i][j - 1] > f[i - 1][j]) {
                    f[i][j] = f[i][j - 1];
                    last[i][j] = 1; // 记录方向 左
                } else {
                    f[i][j] = f[i - 1][j];
                    last[i][j] = 2;// 记录方向 上
                }
            }
        }
    }
    int x = s1.length - 1, y = t1.length - 1;
    while(f[x + 1][y + 1] > 0){
        if(last[x + 1][y + 1] == 3){
            sb.append(s1[x]);
            x--;
            y--;
        }else if(last[x + 1][y + 1] == 2)x--;
        else y--;
    }

    /*  第一种回溯
        for(int i = 1; i <= s1.length; i ++){
            for(int j = 1; j <= t1.length; j ++){
                if(s1[i - 1] == t1[j - 1])f[i][j] = f[i - 1][j - 1] + 1;
                else {f[i][j] = Math.max(f[i][j - 1],f[i - 1][j]);
            }
        }

        int x = s1.length - 1, y = t1.length - 1;
        // 当前 序列长度为0时，出循环
        while(f[x + 1][y + 1] > 0){ 
            if(s1[x] == t1[y]){  // 如果两个序列值相等，回到左上角
                sb.append(s1[x]);
                x--;y--;
            }
            else{
                if(f[x + 1][y + 1] == f[x + 1][y])y--;
                else x--;
            }
        }
        */

    System.out.println(sb.reverse().toString());
}

G - Longest Path

题意:求DAG中求最长的一条路径；

拓扑排序+dp;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Scanner;

public class Main {
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        int N = sc.nextInt(), M = sc.nextInt(), res = 0;
        int[] f = new int[N + 1],degree = new int[N + 1];
        ArrayList[] edges = new ArrayList[N + 1];
        Deque<Integer> q = new ArrayDeque<>();
        for(int i = 0; i <= N; i ++)edges[i] = new ArrayList<Integer>();

        for(int i = 1; i <= M; i ++){
            int v = sc.nextInt(), u = sc.nextInt();
            edges[v].add(u);
            degree[u] ++; // 入度值
        }
        // 当入度值为0，入队
        for(int i = 1; i <= N; i ++)if(degree[i] == 0)q.offer(i);
        while(!q.isEmpty()){
            int cur = q.poll();
            for(Object end : edges[cur]){
                Integer e = (Integer)end;
                f[e] = Math.max(f[cur] + 1,f[e]);
                res = Math.max(res,f[e]);
                // 入读值减一，当没有点指向该点时，入队
                degree[e] --;
                if(degree[e] == 0)q.offer(e);
            }
        }
        
        System.out.println(res);
    }
}

H-Grid 1

题意: 一个迷宫，只能向右和向下走，求从左上角到右下角的路径有多少；

dp 求解， 该点的方案等于上面点的方案 + 左边的方案；

dp(i,j) = dp(i - 1,j) + dp(i,j - 1);

static final int MOD = (int)1e9 + 7;
public static void main(String[] args) {
    int H = sc.nextInt(), W = sc.nextInt();
    char[][] maze = new char[H + 1][W + 1];
    int[][] f = new int[H + 1][W + 1];
    f[1][1] = 1;
    for(int i = 1; i <= H; i ++){
        String s = sc.next();
        for(int j = 1; j <= W; j ++){
            maze[i][j] = s.charAt(j - 1);
        }
    }
    // 地推
    for(int i = 1; i <= H; i ++){
        for(int j = 1; j <= W; j ++){
            if(i == 1 && j == 1)continue;
            if(maze[i][j] == '.')f[i][j] = (f[i - 1][j] + f[i][j - 1]) % MOD;
        }
    }
    System.out.println(f[H][W]);
}

I-Coins

题意: 求硬币正面朝上大于朝下的概率

public static void main(String[] args) {
    int N = sc.nextInt();
    double[] p = new double[N + 1];
    double[][] f = new double[N + 1][N + 1];
    for(int i = 1; i <= N;  i++)p[i] = sc.nextDouble();

    //         投i次，向上次数为j;
    f[0][0] = 1;
    for(int i = 1; i <= N; i ++){
        f[i][0] = f[i - 1][0] * (1 - p[i]);
        for(int j = 1; j <= i; j ++){
            f[i][j] = f[i - 1][j - 1] * p[i] + f[i - 1][j] * (1 - p[i]);
        }
    }
    int cnt;
    if((N&1) == 1) cnt = N + 1 >> 1;
    else cnt = (N >> 1) + 1;
    double res = 0.0;
    for(int i = cnt; i <= N; i++)res += f[N][i];
    System.out.println(res);


    //         向上次数为i，投j次
    //        f[0][0] = 1;
    //        for(int j = 1; j <= N; j ++) {
    //            f[0][j] = f[0][j - 1] * (1 - p[j]);
    //        }
    //        for(int i = 1; i <= N; i++){
    //            for(int j = 1; j <= N; j ++){
    //                f[i][j] = f[i - 1][j - 1] * p[j] + f[i][j - 1] * (1 - p[j]);
    //            }
    //        }
    //        double res = 0.0;
    //        for(int i = 0; i <= N; i ++){
    //            if(i > (N - i))res += f[i][N];
    //        }
    //        System.out.println(res);
}

leetcode-221.最大正方形

题目链接：https://leetcode-cn.com/problems/maximal-square/

dp求解，其左上角，上方，左方的最小值。

class Solution {
    public int maximalSquare(char[][] matrix) {
        int r = matrix.length;
        if(r == 0)return 0;
        int c = matrix[0].length,res = 0;
        int[][] f = new int[r + 1][c + 1];

        for(int i = 1; i <= r; i ++){
            for(int j = 1; j <= c; j ++){
                if(matrix[i - 1][j - 1] == '1'){
                    f[i][j] = Math.min(Math.min(f[i - 1][j - 1],f[i - 1][j]),f[i][j - 1]) + 1;
                    res = Math.max(f[i][j],res);
                }else f[i][j] = 0;
            }
        }
        return res * res;
    }
}

空间优化，dp[j] 为上方，pre 存左上方，dp[j-1]为左方。

class Solution {
    public int maximalSquare(char[][] matrix) {
        int r = matrix.length;
        if(r == 0)return 0;
        int c = matrix[0].length,res = 0, pre = 0;
        int[] f = new int[c + 1];

        for(int i = 1; i <= r; i ++){
            int temp = 0;
            for(int j = 1; j <= c; j ++){
                temp = f[j];
                if(matrix[i - 1][j - 1] == '1'){
                    // 此时f[j] = f[i - 1][j],f[j - 1] = f[i][j - 1], pre = f[i - 1][j - 1];
                    f[j] = Math.min(Math.min(f[j - 1],f[j]),pre) + 1;
                    res = Math.max(res,f[j]);
                }else f[j] = 0;
                pre = temp;
            }
        }
        return res * res;
    }
}
cheerful_man
关注
专栏目录
AtCoder Educational DP Contest 题解
Demilly123的博客
04-14 945
AtCoder Educational DP Contest 题解
Atcoder Educational DP Contest 题解 + 总结
Hacheylight
01-07 5629
待补
Educational DP Contest(第一篇）
exgzc_123的博客
10-06 334
A - Frog 1:线性DP 【问题描述】 有N块石头，编号1,2,…,N. 第 i (1≤i≤N)块的石头高度 hi. 有一只青蛙从第1块石头开始跳 ,它将反复执行以下的动作直到到达石头N: 如果青蛙当前跳到编号为i的石头上，接下来他只能跳到第i+1块石头或者是第i+2块石头，跳一次的代价是两块石头高度差的绝对值。 问青蛙从第一块石头跳到第N块石头的最小代价。 【输入格式】 第一行输入N，表示石头的数量 接下来的一行有N个数h1,h2,…,hN，表示每块石头的高度 【输出格式】 输出最小代价 题解 f[
Educational DP Contest / DP まとめコンテスト部分题解
fyc的博客
01-07 1751
前言： dp太差，开个大坑 因为太多题了，只做现场AC小于300的题
AtCoder Educational DP Contest
最新发布
sblsf的博客
04-16 703
每天只能进行一个活动，且相邻两天不能做相同的活动。现在要挑选一些物品装入袋子里，求选择的物品的最大总价值。现在要挑选一些物品装入袋子里，求选择的物品的最大总价值。很大，直接套用01背包计算，时间和空间肯定一定炸。给定两个字符串，输出它们的任意一个最长公共子序列。经典01背包问题，按照01背包的解法做即可。只能从另外两个状态中的最大值转移过来。由于相邻两天不能做相同的活动，所以。的最小重量，这样就不会炸了。很小，我们可以转换思路，设。，就可以递归输出方案。号石头时的最小代价。号石头时的最小代价。
Atcoder Educational DP Contest
frankchenfu的博客
07-02 768
一、 题目概况 题目来源 完成时间 完成数量 正确率 Atcoder Educational DP Contest 2019/01/24 - 2019/2/2 242424题（除V题和Z题以外） AC：24/2624/2624/26 二、试题分析 A - Frog 1 简单DP。由于只能从前两个石头跳转过来，所以对于每个石头记f(i)f(i)f(i)为到当前为止最优解，则有f(...
Educational Codeforces Round 143 E. Explosions 【动态规划dp】
csxylrf的博客
03-13 141
([Problem - E - Codeforces](https://codeforces.com/contest/1795/problem/E)) ## 思路 ： 我们可以定义两个dp数组，分别表示最高点为i向左能爆破的数量和向右的数量 那么dp（向左爆破的数量）应该是从i向左找到第一个j , 使得 A[i] - (i-j-1) > A[j],也就是说中间那部分一定可以使用等差数列计算，而小于j的部分则是dp[j] 那么我们可以推出 dp(i) = dp(j) + cost(j,i) (使用等差数列
DP好题集选
sher杨的博客
02-16 2575
2019年到了,马上又是省赛区域赛的一年了,但是我的dp水平还是堪忧,所以在众多网站(主要codeforce)搜罗一下dp的好题刷一下,并在此发一下解题报告来督促自己.... 目录 MemSQL Start[c]UP 3.0 - Round 1C.Pie Rules Avito Cool Challenge 2018C. Colorful Bricks(组合数学+dp) Codefo...
[AtCoder Educational DP Contest] V - Subtree（树形dp + 前缀积/后缀积）
03-31 672
如果逆元没有就请别用
Educational DP Contest M - Candies（前缀和优化dp）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
01-29 238
题意：
[AtCoder Educational DP Contest] J - Sushi（期望dp）
03-31 837
反正涉及期望的我压根就不会做
Educational Codeforces Round 22 A. The Contest
Frozensmile的博客
06-06 506
A. The Contest time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Pasha is participating in a contest on one w
Atcoder Educational DP Contest 题解
weixin_30900589的博客
09-25 689
A - Frog 1/B - Frog 2 入门... 1 #include<cstdio> 2 #define abs(a) ((a)>=0?(a):(-(a))) 3 #define min(a,b) ((a)<(b)?(a):(b)) 4 #define maxn 100050 5 using namespace std; ...
A - Frog 1（线性dp）
nankes的博客
10-21 493
题目 题意：有一排高等不一的柱子，一个青蛙从一头跳到另一头，一次最多跳一次或两个柱子，记录高度变化的最小总和； 简单的线性DP： 状态转移方程：dp[i]=Math.min(dp[i-2]+Math.abs(a[i]-a[i-2]),dp[i-1]+Math.abs(a[i]-a[i-1])); 初始化：dp[1]=0；dp[2]=Math.abs(a[2]-a[1]); AC代码： import java.util.*; public class Main { static Scanner sc=new
【Atcoder Dp A Frog1】
我是谁 --- 卡比兽
04-17 260
AtcA 题意 青蛙在1石头上 每次只能跳一步或者跳两步 代价为跳到的石头和跳之前的石头差 问青蛙到n石头最少要花多少代价 设青蛙到 i 个石头的代价为 dp[i] 那么dp[i] = min(dp[i-1]+abs(arr[i]-arr[i-1]),dp[i-2]+abs(arr[i]-arr[i-2]); /* if you can't see the repay Why no...
【算法】- DP(动态规划)
WanDerIngcc的博客
03-10 184
AtCoder-DP专项题目地址，点这 A - Frog 1 #include <iostream> #include<cstring> #include<vector> #include<stdio.h> #include<queue> #include<math.h> #include<stack> #include<math.h> #include<algorithm> #include<
atcoder A - Frog 1（DP）
weixin_30563319的博客
01-09 588
A - Frog 1 Time Limit: 2 sec / Memory Limit: 1024 MB Score :100100points Problem Statement There areNNstones, numbered1,2,…,N1,2,…,N. For eachii(1≤i≤N1≤i≤N), the height of Stoneiiis...
【Atcoder J Sushi】概率dp
我是谁 --- 卡比兽
04-23 1106
Atc J 题意 有n个盘子 分别有 1 2 3 个寿司 每次选一个盘子(可能为空)吃一个盘子 问你吃寿司的期望 dp[a][b][c] a 代表1个寿司的盘子数 b代表2个寿司的盘子数 c代表3个寿司的盘子数 p = (a+b+c)/n 所以吃到寿司的期望发生次数为 n/(a+b+c) 然后再对吃盘子中的期望再分别记忆化搜索下去就行了 /* if you can't see the re...
并行程序测试：使用ConTest进行多线程单元测试
"火龙果软件工程技术中心的文章探讨了如何使用ConTest进行多线程单元测试，以解决并行程序设计中的bug检测和调试难题。文章由并行专家Shmuel Ur和Yarden Nir-Buchbinder撰写，指出常规单元测试在并行程序中的局限性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值