动态规划，数字三角型模型

最新推荐文章于 2024-10-02 21:42:12 发布

静静仔

最新推荐文章于 2024-10-02 21:42:12 发布

阅读量184

点赞数

文章标签：动态规划蓝桥杯算法

本文链接：https://blog.csdn.net/m0_56197283/article/details/122075164

版权

import java.util.*;
public class Main{
     public static void main(String args[]) throws Exception {
         int[][] temp = new int[110][110];
         Scanner sc = new Scanner(System.in);
         int k =  sc.nextInt();
         while( k > 0){
             int m = sc.nextInt();
             int n = sc.nextInt();
             for(int i = 1;i <= m;i++){
                 for(int j = 1;j <= n;j++){
                      temp[i][j] = sc.nextInt();
                 }
             }
             
             int[][] dp = new int[m+1][n+1];
            
             for(int i = 1;i <= m;i++){
                 for(int j = 1;j <= n;j++){
                      dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1])+temp[i][j];
                 }
             }
             
             System.out.println(dp[m][n]);
             
             k--;
         }
     }
}

import java.util.*;

public class Main{
     public static void main(String args[]) {
           Scanner sc = new Scanner(System.in);
           int n = sc.nextInt();
           int[][] nums = new int[n][n];
           for(int i = 0;i <n;i++){
               for(int j = 0 ; j < n;j++){
                    nums[i][j] = sc.nextInt();
               }
           }
           
           int[][] dp = new int[n][n];
           dp[0][0] = nums[0][0];
           for(int i = 1; i < n;i++){
               dp[i][0] = dp[i-1][0] + nums[i][0];
               dp[0][i] = dp[0][i-1] + nums[0][i];
           }
           
           for(int i = 1; i < n;i++){
               for(int j = 1;j < n;j++){
                    dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + nums[i][j];
               }
           }
           
           System.out.print(dp[n-1][n-1]);
     }
}

import java.util.*; 
public class Main {   
    public static void main(String[] args)     {     
        Scanner sc=new Scanner(System.in);   
        int n = sc.nextInt();
        int[][] nums = new int[n+1][n+1];
        int[][][][] dp = new int[n+1][n+1][n+1][n+1];
        while (sc.hasNextInt()) {           
            int a=sc.nextInt();            
            int b=sc.nextInt(); 
            int c= sc.nextInt();
            if (b==0&&a==0&&c == 0) {   
                break ;            
             }            
                  nums[a][b] = c;
              }  
              
              for(int i = 1;i < n+1;i++){
                  for(int j = 1;j < n+1;j++){
                      for(int k = 1;k < n+1;k++){
                          for(int f = 1;f < n+1;f++){
                                     int temp1 = Math.max(dp[i-1][j][k-1][f] , dp[i-1][j][k][f-1]);
                                     int temp2 = Math.max(dp[i][j-1][k-1][f] , dp[i][j-1][k][f-1]);
                                 if(i == k && j == f){
                                     dp[i][j][k][f] = Math.max(temp1,temp2) + nums[k][f];
                                 }else{
                                     
                                     dp[i][j][k][f] = Math.max(temp1,temp2) + nums[k][f] + nums[i][j];
                                 }
                          }
                      }
                  }
              }
              
                sc.close();   
                System.out.print(dp[n][n][n][n]);
    
                
                
          } }

本题实际与上一题类似，传过去不重复传回来，不就是不重复传两次。

import java.util.*;

public class Main{
     public static void main(String args[]){
            Scanner sc = new Scanner(System.in);
            int m = sc.nextInt();
            int n = sc.nextInt();
            int[][] nums = new int[m+2][n+2];
            for(int i = 1;i < m+1;i++){
                for(int j = 1;j < n+1;j++){
                      nums[i][j] = sc.nextInt();
                }
            }
            int[][][][]  dp = new int[m+1][n+1][m+2][n+2];
            for(int i = 1; i < m+1;i++){
                for(int j = 1;j < n+1;j++){
                     for(int k = 1; k < m+1;k++){
                         for(int f = 1; f <n+1;f++){
                                int temp1 = Math.max(dp[i-1][j][k-1][f] , dp[i-1][j][k][f-1]);
                                int temp2 = Math.max(dp[i][j -1][k-1][f] , dp[i][j-1][k][f-1]);
                              if( i == k && j == f){
                                   dp[i][j][k][f] = Math.max(temp1,temp2) +  nums[k][f];
                              }else{
                                   dp[i][j][k][f] = Math.max(temp1,temp2) + nums[k][f] +nums[i][j];
                              }
                         }
                     }
                }
                
            }
            System.out.print(dp[m][n][m][n]);
     }
}