手撕

1、非递归打印杨辉三角

package test1;

public class yanghuisanjiao {

    /**
     * 打印杨辉三角
     * 
     * @author 时光·漫步
     *
     */

    public static void main(String[] args) {
        // 定义数组的长度
        int length = 5;
        int arr[][] = new int[length][];

        // 遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            // 确定二维数组元素的大小
            arr[i] = new int[i + 1];

            // 打印空格
            for (int j = 0; j < arr.length - i - 1; j++) {
                System.out.print("  ");
            }

            // 遍历一维数组
            for (int j = 0; j < arr[i].length; j++) {
                if (j == 0 || arr[i].length - 1 == j) {
                    // 三角形两腰全为 1
                    arr[i][j] = 1;
                } else {
                    // 其他元素等于两肩数字之和
                    arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                }
                System.out.printf("%4d", arr[i][j]);
            }
            System.out.println();
        }
    }

}

 2、字符串的排列

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。

换句话说，第一个字符串的排列之一是第二个字符串的子串。

示例1:

输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba").
 
示例2:

输入: s1= "ab" s2 = "eidboaoo"
输出: False

 

滑动窗口

 public boolean checkInclusion(String s1, String s2) {
        int left=0;
        int right=0;
        int count=0;
        Map<Character,Integer> need=new HashMap<>();
         Map<Character,Integer> window=new HashMap<>();
         for(int i=0;i<s1.length();i++){
             need.put(s1.charAt(i),need.getOrDefault(s1.charAt(i),0)+1);
         }
         while(right<s2.length()){
             char c=s2.charAt(right);
             right++;
             if(need.containsKey(c)){
                 window.put(c,window.getOrDefault(c,0)+1);
                 if(need.get(c).compareTo(window.get(c))==0)count++;
             }
             while(right-left>=s1.length()){
                 if(count==need.size())return true;
                 char d=s2.charAt(left);
                 left++;
                 if(need.containsKey(d)){
                     if(need.get(d).compareTo(window.get(d))==0)count--;
                     window.put(d,window.get(d)-1);
                 }
             }
         }
         return false;
    }

3、 找到字符串中所有字母异位词

给你一个字符串 S、一个字符串 T 。请你设计一种算法，可以在 O(n) 的时间复杂度内，从字符串 S 里面找出：包含 T 所有字符的最小子串。


示例：

输入：S = "ADOBECODEBANC", T = "ABC"
输出："BANC"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-window-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

滑动窗口

 public static String minWindow(String s,String t) {
        int left=0;
        int right=0;
        int count=0;
        int start=0;
        int end=0;
        int len=Integer.MAX_VALUE;
        Map<Character,Integer> needs=new HashMap<>();
        Map<Character,Integer> windows=new HashMap<>();
        for(int i=0;i<t.length();i++) {
            needs.put(t.charAt(i),needs.getOrDefault(t.charAt(i), 0)+1);
        }
        while(right<s.length()) {
            char c=s.charAt(right);
            if(needs.containsKey(c)) {
                windows.put(c,windows.getOrDefault(c, 0)+1);
                if(needs.get(c).compareTo(windows.get(c))==0)count++;
                
            }
            right++;
            while(count==needs.size()) {
                if(right-left<len) {
                    start=left;
                    end=right;
                    len=right-left;
                }
                char d=s.charAt(left);
                 left++;
                if(needs.containsKey(d)) {
                    if(needs.get(d).compareTo(windows.get(d))==0) {
                        count--;
                    }
                    windows.put(d,windows.getOrDefault(d,1)-1);
                }
               
            }
        }
        return len==Integer.MAX_VALUE?"":s.substring(start,end);
    }

 4、输入一个正整数n，输出所有连续可组成n的整数序列（连续整数之和等于targert）

 

package mianjing;

public class test_1 {
    //输入一个正整数n，输出所有连续可组成n的整数序列
    public static void main(String[] args) {
        int n=20;
        for(int i=1;i<n/2+1;i++) {
            int sum=0;
            for(int j=i;j<n;j++) {
                 sum=sum+j;
                if(sum==n) {
                    for(int m=i;m<=j;m++) {
                        System.out.print(m+" ");
                    }
                    System.out.println();
                    break;
                }
            }
            
        }

    }
        
}

 5、0-1背包 （有价值）

/**
     * 0-1背包的优化解法
     * 思路：
     * 只用一个一维数组记录状态，dp[i]表示容量为i的背包所能装入物品的最大价值
     * 用逆序来实现
     */
    public static int ZeroOnePack2(int V,int N,int[] weight,int[] value){
        //动态规划
        int[] dp = new int[V+1];
        for(int i=1;i<N+1;i++){
            //逆序实现
            for(int j=V;j>=weight[i-1];j--){
                dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]);
            }
        }
        return dp[V];       
    }

 

5、0-1背包 （有价值） /** * 0-1背包的优化解法 * 思路： * 只用一个一维数组记录状态，dp[i]表示容量为i的背包所能装入物品的最大价值 * 用逆序来实现 */ public static int ZeroOnePack2(int V,int N,int[] weight,int[] value){ //动态规划 int[] dp = new int[V+1]; for(int i=1;i<N+1;i++){ //逆序实现 for(int j=V;j>=weight[i-1];j--){ dp[j] = Math.max(dp[j-weight[i-1]]+value[i-1],dp[j]); } } return dp[V]; }

[5,0-1 Bèibāo (yǒu jiàzhí) /** * 0-1 bèibāo de yōuhuà jiěfǎ * sīlù: * Zhǐ yòng yīgè yī wéi shùzǔ jìlù zhuàngtài,dp[i] biǎoshì róngliàng wèi i de bèibāo suǒ néng zhuāng rù wùpǐn de zuìdà jiàzhí * yòng nìxù lái shíxiàn */ public static int ZeroOnePack2(int V,int N,int[] weight,int[] value){ //dòngtài guīhuà int[] dp = new int[V+1]; for(int i=1;i<N+1;i++){ //nìxù shíxiàn for(int j=V;j>=weight[i-1];j--){ dp[j] = Math.Max(dp[j-weight[i-1]]+value[i-1],dp[j]); } } return dp[V]; }]

5,0-1 backpack (valuable)

/ **
* Optimization Solution 0-1 backpack
* Ideas:
* Only one recording state of one-dimensional array, dp [i] denotes the i capacity charged article can backpack maximum value
* Use reverse to achieve
* /
public static int ZeroOnePack2 (int V, int N, int [] weight, int [] value) {
// Dynamic Programming
int [] dp = new int [V + 1];
for (int i = 1; i <N + 1; i ++) {
// reverse achieve
for (int j = V; j> = weight [i-1]; j -) {
dp [j] = Math.max (dp [j-weight [i-1]] + value [i-1], dp [j]);
}
}
return dp [V];
}