动态规划学习专题3

最新推荐文章于 2020-08-11 10:31:57 发布
最新推荐文章于 2020-08-11 10:31:57 发布
阅读量191 收藏
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41888669/article/details/90647008
版权

//字串 只能是去掉某些字符，不能改变某些字符

 

 

 

 

 

 

 public int longestCommonSubsequence(String A, String B) {
        // write your code here
        int m =A.length();
        int n =B.length();
        if (m==0||n==0) return 0;
        char[] s1 =A.toCharArray();
        char[] s2 =B.toCharArray();

        //f[i][j]  表示  A的 第i个  和b的第j个最多匹配多少

        int[][] f = new int[m+1][n+1];

        for (int i = 0; i <m+1 ; i++) {
            for (int j = 0; j <n+1 ; j++) {
                if (i==0||j==0){
                    f[i][j]=0;
                     continue;
                }
                    f[i][j] =Math.max(f[i-1][j],f[i][j-1]);
                if (s1[i-1]==s2[j-1]){
                    f[i][j] =Math.max(f[i][j],f[i-1][j-1]+1);
                }
            }
        }
        return f[m][n];
    }

//将最长子序列打印输出

 public static void main(String[] args) {
        longestCommonSubsequence("jiuzhang","lijiang");
    }

    public static int longestCommonSubsequence(String A, String B) {
        // write your code here
        int m =A.length();
        int n =B.length();
        if (m==0||n==0) return 0;
        char[] s1 =A.toCharArray();
        char[] s2 =B.toCharArray();

        //f[i][j]  表示  A的 第i个  和b的第j个最多匹配多少

        int[][] f = new int[m+1][n+1];
        int[][] pai = new int[m+1][n+1];

        for (int i = 0; i <m+1 ; i++) {
            for (int j = 0; j <n+1 ; j++) {
                if (i==0||j==0){
                    f[i][j]=0;
                    continue;
                }
                f[i][j] =Math.max(f[i-1][j],f[i][j-1]);
                if (f[i][j]==f[i-1][j]){
                    pai[i][j]=1;
                }else if (f[i][j]==f[i][j-1]){
                    pai[i][j] =2;
                }

                if (j>0&&s1[i-1]==s2[j-1]){
                    f[i][j] =Math.max(f[i][j],f[i-1][j-1]+1);
                    if (f[i][j]==f[i-1][j-1]+1){
                        pai[i][j]=3;
                    }
                }
            }
        }
        // recover f[m][n]->   f[0][0]
        char[] res =new char[f[m][n]];
        int p =f[m][n] -1;
        int i = m;
        int j = n;
        while (i>0&&j>0){
            if (pai[i][j]==1){
                --i;
            }else if (pai[i][j]==2){
                --j;
            }else {
                res[p--] = s1[i-1];
                --i;
                --j;
            }
        }

        for (p = 0; p <f[m][n] ; p++) {
            System.out.print(res[p]);
        }

        return f[m][n];
    }

  public boolean isInterleave(String ss1, String ss2, String ss3) {
        // write your code here
        char[] s1 =ss1.toCharArray();
        char[] s2 =ss2.toCharArray();
        char[] s3 =ss3.toCharArray();
        int m = s1.length;
        int n  = s2.length;
        if (s3.length!=m+n) return false;

        boolean[][] f = new boolean[m+1][n+1];

        for (int i = 0; i <m+1 ; i++) {
            for (int j = 0; j <n+1 ; j++) {
                if (i==0&&j==0) {
                    f[i][j]=true;
                    continue;
                }
                f[i][j] =false;
                if (i>0&&s3[i+j-1]==s1[i-1]){
                    f[i][j]|=f[i-1][j];
                }
                if (j>0&&s3[i+j-1]==s2[j-1]){
                    f[i][j]|= f[i][j-1];
                }
            }
        }
        return f[m][n];

    }

 

 

 

 

  public int minDistance(String word1, String word2) {
        // write your code here
        char[] s1 = word1.toCharArray();
        char[] s2 = word2.toCharArray();
        int m = s1.length;
        int n = s2.length;

        int[][] f = new int[m+1][n+1];


        for (int i = 0; i <m+1 ; i++) {
            for (int j = 0; j <n+1 ; j++) {
                if (i==0) {
                    f[i][j] = j;
                    continue;
                }
                if (j==0){
                    f[i][j] = i;
                    continue;
                }
                //                  delete      add
                f[i][j] = Math.min(f[i-1][j]+1,f[i][j-1]+1);
                f[i][j] = Math.min(f[i][j],f[i-1][j-1]+1);//replace
                if (s1[i-1]==s2[j-1]){
                    f[i][j] = Math.min(f[i][j],f[i-1][j-1]); //same
                }
            }
        }
        return f[m][n];
    }

 

 

 public int numDistinct(String S, String T) {
        // write your code here
        char[] s1 = S.toCharArray();
        char[] s2 = T.toCharArray();
        int m =s1.length;
        int n =s2.length;
        int[][] f =new int[m+1][n+1];
        for (int i = 0; i <=m ; i++) {
            for (int j = 0; j <=n ; j++) {
                if (j==0){
                    f[i][j] = 1;
                    continue;
                }
                if (i==0){
                    f[i][j] =0;
                    continue;
                }
            
                f[i][j] = f[i-1][j];
                if (s2[j-1]==s1[i-1]){
                    f[i][j]+= f[i-1][j-1];
                }
                
            }
        }

      return f[m][n];
        
    }

  public boolean isMatch(String ss, String pp) {
        // write your code here
        char[] s1 = ss.toCharArray();
        char[] s2 = pp.toCharArray();
        int m = s1.length;
        int n = s2.length;
        boolean[][] f = new boolean[m+1][n+1];

        for (int i = 0; i <m+1 ; i++) {
            for (int j = 1; j <n+1 ; j++) {
                f[i][j]=false;
                  f[0][0] =true;
                if (s2[j-1]!='*'){
                    if (i>0&&(s1[i-1]==s2[j-1]||s2[j-1]=='.')){
                        f[i][j] =f[i-1][j-1];
                    }
                }else {
                    if (j>=2) f[i][j] |=f[i][j-2];
                    if (i>=1&&j>=2){
                        f[i][j] |=f[i-1][j]&&(s2[j-2]=='.'||s2[j-2]==s1[i-1]);
                    }
                }
            }
        }
        return f[m][n];
    }

 

 

public boolean isMatch(String ss1, String ss2) {
        // write your code here
        char[] s1 =ss1.toCharArray();
        char[] s2 = ss2.toCharArray();
        int m = s1.length;
        int n = s2.length;
        boolean f[][] = new boolean[m+1][n+1];
        
        f[0][0] = true;

        for (int i = 0; i <m+1 ; i++) {
            for (int j = 1; j <n+1 ; j++) {
                if (i>0&&(s2[j-1]=='?'||s2[j-1]==s1[i-1])){
                    f[i][j] =f[i-1][j-1];
                }
                if (s2[j-1]=='*'){
                    f[i][j] = f[i][j-1];  // 先不选 
                    if(i>0) f[i][j] |= f[i-1][j];
                }
            }
        }
        
       return f[m][n];
    }

  public int findMaxForm(String[] strs, int m, int n) {
        // write your code here
        int len =strs.length;
        int[] cnt0 = new int[len];
        int[] cnt1 = new int[len];

        for (int i = 0; i <len ; i++) {
            cnt0[i]=cnt1[i]=0;
            char[] s = strs[i].toCharArray();
            for (int j = 0; j <s.length ; j++) {
                if (s[j]=='0'){
                    ++cnt0[i];
                }else{
                    ++cnt1[i];
                }

            }
        }

        int[][][] f =new int[len+1][m+1][n+1];

        for (int i = 0; i <=m ; i++) {
            for (int j = 0; j <=n ; j++) {
                f[0][i][j] = 0;
            }
        }

        for (int i = 1; i <=len ; i++) {
            for (int j = 0; j <=m ; j++) {
                for (int k = 0; k <=n ; k++) {
                    f[i][j][k] = f[i-1][j][k];
                    if (j>=cnt0[i-1]&&k>=cnt1[i-1]){
                        f[i][j][k] = Math.max(f[i][j][k],
                                f[i-1][j-cnt0[i-1]][k-cnt1[i-1]]+1);
                    }
                }
            }
        }
          return f[len][m][n];
    }
public int findMaxForm(String[] strs, int m, int n) {
        // write your code here
        int len =strs.length;
        int[] cnt0 = new int[len];
        int[] cnt1 = new int[len];

        for (int i = 0; i <len ; i++) {
            cnt0[i]=cnt1[i]=0;
            char[] s = strs[i].toCharArray();
            for (int j = 0; j <s.length ; j++) {
                if (s[j]=='0'){
                    ++cnt0[i];
                }else{
                    ++cnt1[i];
                }

            }
        }

        int[][][] f =new int[2][m+1][n+1];
        int old,now =0;
        for (int i = 0; i <=m ; i++) {
            for (int j = 0; j <=n ; j++) {
                f[now][i][j] = 0;
            }
        }

        for (int i = 1; i <=len ; i++) {
            old=now;
            now=1-now;
            for (int j = 0; j <=m ; j++) {
                for (int k = 0; k <=n ; k++) {
                    f[now][j][k] = f[old][j][k];
                    if (j>=cnt0[i-1]&&k>=cnt1[i-1]){
                        f[now][j][k] = Math.max(f[now][j][k],
                                f[old][j-cnt0[i-1]][k-cnt1[i-1]]+1);
                    }
                }
            }
        }
        return f[now][m][n];
    }

 

 

    public int MinAdjustmentCost(List<Integer> A, int target) {
        // write your code here
        int n = A.size();
        int[][] f =new int[n+1][101];
        //init
        for (int i = 1; i <=100 ; i++) {
            f[1][i] = Math.abs(A.get(0)-i);
        }

        int res = Integer.MAX_VALUE; 
        for (int i = 2; i <=n ; i++) {
            for (int j = 1; j <=100 ; j++) {
                f[i][j] = Integer.MAX_VALUE;
                for (int k = j-target; k <=j+target ; k++) {
                    if (k<1||k>100){
                        continue;
                    }
                    f[i][j] = Math.min(f[i][j],f[i-1][k]+
                            Math.abs(A.get(i - 1) -j));  //调整代价
                    if (i==n){
                        res=Math.min(res,f[i][j]);
                    }
                   
                }
            }
        }
        return res;
    }

public int kSum(int[] A, int k, int target) {
        // write your code here
        int  n = A.length;
        int[][][] f = new int[n+1][k+1][target+1];
        
        f[0][0][0]=1;

        for (int i = 1; i <=n ; i++) {
            for (int j = 0; j <=k ; j++) {
                for (int l = 0; l <=target ; l++) {
                    f[i][j][l] = f[i-1][j][l];
                    if (j>0&&l-A[i-1]>=0){
                        f[i][j][l] = f[i][j][l] + 
                                f[i-1][j-1][l-A[i-1]];
                    }
                }
            }
        }
        return f[n][k][target];
    }

滚动数组 版本 

 

  public int longestIncreasingSubsequence(int[] A) {
        // write your code here
        int n = A.length;
        if (n==0) return 0;
        int[] b = new int[n+1];  //  当f的只是i，最小的结尾值
        int top =0; //最长子序列的长度
        b[0] = Integer.MIN_VALUE;
        for (int i = 0; i <n ; i++) {
            int start = 0;
            int stop =top;
            int j=0 ; //最后一个小于它的结尾值
            while (start<=stop){
                int mid =(start+stop)>>1;
                if (b[mid]<A[i]){
                    j=mid;
                    start = mid+1;
                }
                else {
                    stop=mid-1;
                }
            }
            b[j+1] =A[i]; //f[i] =j+1;
            if (j+1>top){
                top=j+1;
            }
        }
        return top;

    }

 

 

 

 static class TireNode{
        TireNode[] sons;
        boolean hasword;
         String word;

       public  TireNode(){
          sons =new TireNode[26];// a=0
           for (int i = 0; i <26 ; i++) {
               sons[i] = null;
           }
           hasword =false;
       }

       public static void insert(TireNode root,String wordStr){
           char[] word = wordStr.toCharArray();
           TireNode p =root;

           for (int i = 0; i <word.length ; i++) {
               int c = word[i] -'a';
               if (p.sons[c]==null){
                   p.sons[c] = new TireNode();
               }
               p=p.sons[c];
           }
           p.hasword = true;
           p.word  = wordStr;
       }
    }

    char[] target =null;
    int K=0;
    int[] f =null;
    int n=0;
    List<String> res =null;

    private void dfs(TireNode p,int[] f){
        int[] nf  =new int[n+1];
        if (p.hasword){
            if (f[n]<=K){
                res.add(p.word);
            }
        }

        for (int i = 0; i <26 ; i++) {
            if (p.sons[i]==null){
                continue;
            }
            nf[0] = f[0]+1;
            for (int j = 1; j <=n ; j++) {
                nf[j] = Math.min(Math.min(nf[j-1]+1,f[j]+1),f[j-1]+1);
                int c= target[j-1]-'a';
                if (c==i){
                    nf[j] =Math.min(nf[j],f[j-1]);
                }

            }
            dfs(p.sons[i],nf);  
        }
    }

    public List<String> kDistance(String[] words, String targetStr, int k) {
        // write your code here
        target =targetStr.toCharArray();
        n = target.length;
        K = k;
        res = new ArrayList<String>();

        //1 init tire
        TireNode root = new TireNode();
        for (int i = 0; i <words.length ; i++) {
            TireNode.insert(root,words[i]);
        }
        
        //init f
        f =new int[n+1];
        for (int i = 0; i <=n ; i++) {
            f[i]=i;
        }
        // dfs
        dfs(root,f);
        
        return res;

    }

 

 

 public boolean canCross(int[] A) {
        // write your code here

        int n =A.length;
        HashMap<Integer,HashSet<Integer>> f = new HashMap<>();

        for (int i = 0; i <n ; i++) {
            f.put(A[i],new HashSet<>());
        }
        f.get(A[0]).add(0);

        for (int i = 0; i <n ; i++) {
            HashSet<Integer> tmp = new HashSet<>(f.get(A[i]));
            for (int k :tmp) {
                for (int delta = -1; delta <=1 ; delta++) {
                    
                    int t =A[i] + (k+delta);
                    if (f.containsKey(t)){
                        f.get(t).add(k+delta);
                    }
                }
            }
        }
        return !f.get(A[n-1]).isEmpty();
    }

 

 

 

 

public int maxSquare(int[][] matrix) {
        // write your code here
        if (matrix==null||matrix.length==0||matrix[0].length==0){
            return 0;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] f = new int[m][n];
        int res= 0;
        for (int i = 0; i <m ; i++) {
            for (int j = 0; j <n ; j++) {
                if (matrix[i][j] == 0){
                    f[i][j] = 0;
                    continue;
                }
                
                //A[i][j] = 1
                if (i==0||j==0){
                    f[i][j] =1;
                    res = Math.max(1,res);
                    continue;
                }
                f[i][j] = Math.min(Math.min(f[i-1][j],f[i-1][j-1]),f[i][j-1])+1;
                res = Math.max(f[i][j]*f[i][j],res);
            }
        }
        return res;
    }

 

 

 

飞飞学Java
关注
专栏目录
动态规划学习笔记
07-30
ACM训练笔记，新手从0入门，浅显易懂，markdown语言编写
动态规划学习专题2
weixin_41888669的博客
05-28 162
public int maxProfit(int[] prices) { int n = prices.length; if (n==0) return 0; // 最多两次买卖 两次 买卖 一共有五个阶段 int[][] f = new i...
动态规划专题学习
蜗牛君
07-06 244
https://leetcode-cn.com/problems/wildcard-matching/solution/zi-fu-chuan-dong-tai-gui-hua-bi-xu-miao-dong-by-sw/ 动态规划解题框架： 一.明确dp数组的含义 构造一维dp[i]、二维dp[i][j]，明确其代表了什么状态，一般与题目的目的有关。如解决通配符问题，就定义boolean[][] dp表示s[i-1]与p[j-1]的匹配成功与否；解决最长子数组问题，就定义dp[][]表示A[i-1]与B[
剑指 Offer 19. 正则表达式匹配--主站 10 题
trhflybingo的博客
08-11 83
方法：动态规划 算法思想：倒数匹配 时间复杂度： 空间复杂度： 边界条件： 补充知识： classSolution{ publicbooleanisMatch(StringA,StringB){ intn=A.length(); intm=B.length(); boolean[][]f=newboolean[n+1][m+1]; //存储boolean类型的 ...
动态规划专题讲解
01-12
动态规划方法广泛应用于数据结构与算法的教学中，由于其能够解决很多看似复杂的问题，因此学习动态规划是提升算法设计能力的重要步骤。掌握动态规划的思路，不仅能够应对算法面试中的相关问题，更可以在实际工作中...
动态规划专题-清华大学IOI金牌讲座
02-10
【动态规划专题】是计算机科学领域中的一种算法思想，它主要应用于解决最优化问题，尤其在处理具有重叠子问题和最优子结构...通过学习和掌握动态规划，我们可以提升解决问题的能力，进一步拓宽在计算机科学领域的视野。
动态规划专题课件
12-06
本专题课件深入探讨了动态规划的核心原理和应用。 一、动态规划的基本概念 动态规划的核心在于“重叠子问题”和“最优子结构”。当一个问题的最优解包含其子问题的最优解时，我们说这个问题具有最优子结构。而如果...
动态规划的概要介绍与分析
09-06
此外，还有大量的文献材料和在线教程可供学习，如GeeksforGeeks、Topcoder和Tutorialspoint等平台提供的动态规划专题内容。 项目源码示例： 以下是一个使用Python实现的动态规划算法示例，用于解决最长递增子序列...
numexpr-2.8.3-cp38-cp38-win_amd64.whl
10-14
numexpr-2.8.3-cp38-cp38-win_amd64.whl
ujson-5.3.0-cp311-cp311-win_amd64.whl
10-14
ujson-5.3.0-cp311-cp311-win_amd64.whl
基于MATLAB车牌识别程序技术实现面板GUI.zip
10-14
vos3000
RJFireWall-maste赛资源
10-14
RJFireWall-maste赛资源
msgpack-1.0.4-cp39-cp39-win_amd64.whl
10-14
msgpack-1.0.4-cp39-cp39-win_amd64.whl
基于 YOLOv11 的混凝土缺陷检测系统（包含详细的完整的程序和数据）
10-14
内容概要：本文提供了从零开始搭建的基于 YOLOv11 模型的混凝土缺陷检测系统教程，覆盖了整个流程，如开发配置指导，训练集搭建、模型的使用方法到最终集成图形界面交付应用等内容，尤其注重图像预处理及增广手段的有效利用，帮助读者建立高效的系统以满足工程中的实时监测需求。此外还包括对未来发展方向的具体展望，比如引入新型检测器或进一步扩展故障类别。 适合人群：适用于具有一定Python基础、想探索目标检测领域尤其是从事土木工程质量监督的技术工作者。 使用场景及目标：适合对有形结构如混凝土建筑的质量检验需要的公司部门，以提高检测的精确度同时加快检测流程的速度。 其他说明：项目代码附在文中，方便大家快速上手测试并进一步深入研究。对于那些对模型效果不满意的，本文给出了提升系统效能的具体注意点，譬如持续优化迭代以及增加系统设置自由度。
用 Python 实现简单网页爬虫并保存为CSV教程.txt
最新发布
10-14
本文提供了详细的步骤教您构建基于Python的网页爬虫程序，主要讲解了如何获取并解析指定新闻网站的文章标题及其URL。它通过使用Python内置包：Requests，BeautifulSoup和Pandas三个开源软件包完成数据采集和存盘任务。 适合人群：有一定的编程技能且正在学习或已经初步掌握了爬虫基础知识的技术员或学生。 使用场景及目标：①从网络上自动拉去大量信息，降低人工收集的成本;②将爬虫获得的一手资料存档进表格形式。 此外：由于每个网站的架构各异，所以务必在实际工作中注意调整细节参数；并且在做互联网抓取时需关注相关法律法规，不可随意触犯他人的合法权益，尤其应注意机器人协议（Robots.txt）。
chompack-2.3.3-cp35-cp35m-win_amd64.whl
10-14
chompack-2.3.3-cp35-cp35m-win_amd64.whl
sparsesvd-0.2.2-cp38-cp38-win_amd64.whl
10-14
sparsesvd-0.2.2-cp38-cp38-win_amd64.whl
pendulum-2.0.5-cp35-cp35m-win_amd64.whl
10-14
pendulum-2.0.5-cp35-cp35m-win_amd64.whl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值