11111笔记

yd_52

已于 2023-09-17 15:34:05 修改

阅读量429

点赞数

文章标签： java 算法数据结构

于 2022-11-03 18:02:49 首次发布

本文链接：https://blog.csdn.net/qq_54837037/article/details/127675475

版权

文章目录

算法
leetcode
其他

算法

1.技巧

1.1 split()字符串按空格进行切割

String abc = "12 13 32 32 324 32";
String[] s = abc.split(" ");
int[] ints = new int[s.length];
for (int i = 0; i < s.length; i++) {
    ints[i]=Integer.parseInt(s[i]);
}
for (int i :
     ints) {
    System.out.print(i+" ");
}

1.2数据流List.stream().filter过滤

public class StreamTest {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");
        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");
        //男演员只要名字为3个字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
        //女演员只要姓林的，并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);
      	// 将流中的数据封装成Actor对象之后打印
      	stream.forEach(name -> {
            Actor actor = new Actor(name);
            System.out.println(actor);
        }); 
    }
}

1.3contains方法

	while (sequence.contains(s)){
}

2.数据结构

2.1二分查找

//二分查找 BinarySearch
public static void main(String[] args) {
    int[] ints = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int number = 3;

    int index = BinarySearch(ints, number);
    System.out.println(index);

}

private static int BinarySearch(int[] ints, int number) {
    int l = 0;
    int r = ints.length - 1;
    int mid = l + (l + r) >> 2;
    while (l <= r) {
        if (ints[mid] > number) {
            r = mid - 1;
        } else if (ints[mid] < number) {
            l = mid + 1;
        }else {
            return mid;
        }
    }
    return -1;
}

2.2稀疏数组

public static void main(String[] args) {
        int[][] arr = new int[10][10];
        arr[4][6] = 4;
        System.out.println("原数组：");
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------");
        //转为稀疏数组
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (arr[i][j] != 0) {
                    sum++;
                }
            }
        }
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = 10;
        sparseArr[0][1] = 10;
        sparseArr[0][2] = sum;
        int count = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (arr[i][j] != 0) {
                    sparseArr[count + 1][0] = i;
                    sparseArr[count + 1][1] = j;
                    sparseArr[count + 1][2] = arr[i][j];
                }
            }
        }
        System.out.println("打印稀疏数组：");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
        }
        System.out.println("-------------------------------------");
        System.out.println("稀疏数组转为普通数组：");
        int row = sparseArr[0][0];
        int col = sparseArr[0][1];
        int sum1 = sparseArr[0][2];
        int[][] chessArr = new int[row][col];
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
   /*     for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(chessArr[i][j] + "\t");
            }
            System.out.println();
        }*/
        for (int[] r :
                chessArr) {
            for (int data:
                r ) {
                System.out.print(data+"\t");
            }
            System.out.println();
        }
    }

2.3数组模拟队列


/**
 * @author yangyiliy_liuyang
 * 2022/10/28
 * @version 1.0
 * 数组模拟队列
 */
public class arrayQueueDemo {
    public static void main(String[] args) {
        arrayQueue arrayQueue = new arrayQueue(3);
        char key = ' ';
        Scanner sc = new Scanner(System.in);
        boolean bool = true;
        System.out.println("show");
        System.out.println("exit");
        System.out.println("add");
        System.out.println("get");
        System.out.println("head");
        while (bool) {
            key = sc.next().charAt(0);
            switch (key) {
                case 's':
                    arrayQueue.showQueue();
                    break;
                case 'e':
                    sc.close();
                    bool = false;
                    break;
                case 'a':
                    System.out.println("请输入一个值加入队列：");
                    int value = sc.nextInt();
                    arrayQueue.addQueue(value);
                    break;
                case 'g':
                    int result = arrayQueue.getQueue();
                    System.out.println("取出的值为："+result);
                    break;
                case 'h':
                    int head = arrayQueue.headQueue();
                    System.out.println("当前队列头元素是："+head);
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出。");
    }
}

class arrayQueue {
    private int maxSize;
    //队列头
    private int front;
    //队列尾
    private int rear;
    private int[] arr;

    public arrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = -1;
        rear = -1;
    }

    boolean isFull() {
        return rear == maxSize - 1;
    }

    boolean isEmpty() {
        return rear == front;
    }

    void addQueue(int n) {
        if (isFull()) {
            throw new RuntimeException("队列已满，不能添加元素。");
        }
        rear++;
        arr[rear] = n;
    }

    int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，不能取出队列。");
        }
        front++;
        return arr[front];
    }

    void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，不能打印队列。");
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据。");
        }
        return arr[front + 1];
    }

}

2.4冒泡排序

public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 423, 45, 563, 34};
        arr = BubbleSort(arr);
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    private static int[] BubbleSort(int[] arr) {
        //外层循环控制的是次数=数组长度减一
        for (int i = 0; i < arr.length-1; i++) {
            //-1是为了数组不越界
            //-i每次结束后少比较一个数
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }
}

2.5环形队列


/**
 * @author yangyiliy_liuyang
 * 2022/10/30
 * @version 1.0
 * 环形队列
 */
public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        //其队列最大有效数据最大是3
        CircleArrayQueue circleArrayQueue = new CircleArrayQueue(4);
        char key = ' ';
        Scanner sc = new Scanner(System.in);
        boolean bool = true;
        System.out.println("show");
        System.out.println("exit");
        System.out.println("add");
        System.out.println("get");
        System.out.println("head");
        while (bool) {
            key = sc.next().charAt(0);
            switch (key) {
                case 's':
                    circleArrayQueue.showQueue();
                    break;
                case 'e':
                    sc.close();
                    bool = false;
                    break;
                case 'a':
                    System.out.println("请输入一个值加入队列：");
                    int value = sc.nextInt();
                    circleArrayQueue.addQueue(value);
                    break;
                case 'g':
                    int result = circleArrayQueue.getQueue();
                    System.out.println("取出的值为：" + result);
                    break;
                case 'h':
                    int head = circleArrayQueue.headQueue();
                    System.out.println("当前队列头元素是：" + head);
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出。");
    }
}


class CircleArrayQueue {
    private int maxSize;
    //队列头
    private int front;
    //队列尾
    private int rear;
    private int[] arr;

    CircleArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = 0;
        rear = 0;
    }

    boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    boolean isEmpty() {
        return rear == front;
    }

    void addQueue(int n) {
        if (isFull()) {
            throw new RuntimeException("队列已满，不能添加元素。");
        }
        arr[rear] = n;
        rear = (rear + 1) % maxSize;
    }

    int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，不能取出队列。");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

    void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，不能打印队列。");
            return;
        }
        for (int i = front; i < (rear + maxSize - front) % maxSize; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空，没有数据。");
        }
        return arr[front];
    }

}

2.6链表

1.求单链表中有效节点的个数

 private static int getLength(HeroNode head){
        if (head.getNext()==null){
            return 0;
        }
        int length=0;
        HeroNode temp = head.getNext();
        while(temp!=null){
            length++;
            temp=temp.getNext();
        }
        return length;
    }

2.查找单链表的倒数第k个节点

    //查找单链表倒数第k个元素
    private static HeroNode findLastIndexKNode(HeroNode head, int k) {
        if (head.getNext() == null) {
            return null;
        }
        //第一遍遍历得到链表的长度
        HeroNode temp = head.getNext();
        int length = 0;
        while (temp != null) {
            length++;
            temp = temp.getNext();
        }
        //第二遍遍历 遍历到length-k的位置，就是倒数第k个节点
        if (k <= 0 || k > length) {
            return null;
        }
        temp = head.getNext();
        for (int i = 0; i < length - k; i++) {
            temp=temp.getNext();
        }
        return  temp;
    }

3.反转链表

/*
双指针反转链表
*/
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;
        ListNode pre = null;
        while(cur!=null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}
/*
改为递归
*/
class Solution {
    public ListNode reverseList(ListNode head) {
       return reverse(head,null);
    }
    public static ListNode reverse(ListNode cur,ListNode pre){
        if(cur == null){
            return pre;
        }
        ListNode temp = cur.next;
        cur.next = pre;
        return reverse(temp,cur);
    }
}
/*
1.定义一个新的头结点reversehead
2.遍历原来的链表，每遍历一个节点，取出节点放入reversehead头结点后面
3.head.next = reversehead
*/

4.逆序打印单链表

/*
栈
*/
stack

2.7红黑树

2.8双向链表

2.9串

默认字符从1索引开始存储，0为空

/*
串的顺序存储
*/
#define MAXLENG 255
typedef struct {
    //静态数组实现
    char ch[MAXLEN];
    int length;
}SString;
/*
串的链式存储
*/
#define MAXLENG 255
typedef struct {
    //动态数组实现 堆空间实现
    char *ch;
    int length;
}HString;
HString S;
S.ch = (char*)malloc(sizeof(char)*MAXLEN);
S.length = 0;

/*typedef struct StringNode {
	char ch；//每个节点存放一个字符
	//char ch[4];//一个节点存放四个
	struct StringNode* next;
}StringNode,*String;*/
//malloc结束后要free

1.求子串

public static void main(String[] args) {
    SeqString seqString = new SeqString();
    SeqString subString = SubString(seqString, 2, 4);
    System.out.println(subString);
}

//求子串
public static SeqString SubString(SeqString s, int pos, int len) {
    SeqString sub = new SeqString();
    if (pos + len - 1 > s.length) {
        return null;
    }
    for (int i = pos; i <= pos + len - 1; i++) {
        sub.str[i - pos + 1] = s.str[i];
    }
    sub.length = len;
    return sub;
}

2.字符串比较


//字符串比较
public static int ComString(SeqString s, SeqString t) {
    //比较每一个字符串 =返回= >返回> <返回<
    for (int i = 1; i <= s.length || i <= t.length; i++) {
        if (s.str[i] != t.str[i]) {
            return s.str[i] - t.str[i];
        }
    }
    //字符都相等，比较字符长度 长的返回正数
    return s.length - t.length;
}

3.1定位操作

/*
返回 s和t串值相等的子串的第一次出现的位置
用了其他操作
*/
	public static int index(SeqString s, SeqString t) {
        int i =1;
        SeqString sub = null;
        while(i<=s.length-t.length+1){
            sub = SubString(s,i,t.length);
            if (ComString(sub,t)!=0) {
                i++;
            }
              //返回子串在主串中的位置
            return i;
        }
          //在主串中不存在t相等的子串
        return 0;
    }

3.2模式匹配(定位操作)

    //返回 s和t串值相等的子串的第一次出现的位置
    public static int index(SeqString s, SeqString t) {
        int i = 1;
        int j = 1;
        while (i <= s.length && j < t.length) {
            if (s.str[i] == t.str[j]) {
                ++i;
                ++j;
            } else {
                i = i - j + 2;
                j = 1;
            }
        }
        if (j > t.length) {
                return i - t.length;
           }
        return 0;
    }

3.3KMP模式匹配

    private static int index_kmp(SeqString s, SeqString t, int[] next) {
        int i = 1;
        int j = 1;
        while(i<s.length&&j<t.length){
            if(i==0||s.str[i]==t.str[i]){
                i++;j++;
            }else {
                j=next[j];
            }
        }
        if (j>=t.length){
            return i-t.length;
        }
        return 0;
    }

求模式串的next数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OXp276He-1668424318068)(C:\Users\yangyiliy\AppData\Roaming\Typora\typora-user-images\image-20221107211927263.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o5Bg4S4o-1668424318069)(C:\Users\yangyiliy\AppData\Roaming\Typora\typora-user-images\image-20221107212547828.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MQCT4mNT-1668424318069)(C:\Users\yangyiliy\AppData\Roaming\Typora\typora-user-images\image-20221108163741264.png)]

2.10贪心算法

局部最优解推全局最优解

常识性推导加上举反例

靠自己手动模拟，如果模拟可行，就可以试一试贪心策略，如果不可行，可能需要动态规划。

leetcode

1.检查两个字符串数组是否相等

/*
拼接字符串在比较
*/
public class Main {
    public static void main(String[] args) {
        String[] word1={"ab","c"};
        String[] word2 ={"a","bc"};
        boolean b = arrayStringAreEqual(word1, word2);
        System.out.println(b);
    }
    private static boolean arrayStringAreEqual(String[] word1,String[] word2){
        String s1="";
        String s2="";
        for (int i = 0; i < word1.length; i++) {
            s1+=word1[i];
        }
        for (int i = 0; i < word2.length; i++) {
            s2+=word2[i];
        }
        if(s1.equals(s2)){
            return true;
        }
        return false;
    }
}

2.网络信号最好的坐标

public class Main {
    public static void main(String[] args) {
        int[][] towers = {{1, 2, 5}, {2, 1, 7}, {3, 1, 9}};
        int radius = 2;
        int[] ints = bestCoordinginate(towers, radius);
        for (int i :
                ints) {
            System.out.print(i + " ");
        }
    }

    private static int[] bestCoordinginate(int[][] towers, int radius) {
        int[] ansult = {0, 0};
        int maxv = 0;
        for (int i = 0; i < 55; i++) {
            for (int j = 0; j < 55; j++) {
                int sig = 0;
                int a = 0;
                int b = 0;
                for (int k = 0; k < towers.length; k++) {
                    a = towers[k][0];
                    b = towers[k][1];
                    //满足条件第k个塔可以覆盖
                    int i1 = (a - i) * (a - i) + (b - j) * (b - j);
                    if (i1 <= radius) {
                        sig += towers[k][2] / (1 + Math.sqrt(i1));
                    }
                }
                if (sig > maxv) {
//                if (sig > maxv && (i < a || (i == a && j < b))) { //出错案例过了38%
                    maxv = sig;
                    ansult = new int[]{i, j};
                }
            }
        }
        return ansult;
    }
}

3.最大重复子字符串


/**
 * @author yangyiliy_liuyang
 * 2022/11/3
 * @version 1.0
 * 1668 最大重复子字符串
 */
public class Main {
    public static void main(String[] args) {
        String sequence ="ababc";
        String word = "ba";
        int i = maxRepeating(sequence, word);
        System.out.println(i);
    }

    public static int maxRepeating(String sequence, String word) {
        String s = word;
        int ans = 0;
        while (sequence.contains(s)){
            ++ans;
            s+=word;
        }
        return ans;
    }
}

4.到达终点数字


/**
 * @author yangyiliy_liuyang
 * 2022/11/3
 * @version 1.0
 * 754 到达终点数字
 */
class Solution {
    public int reachNumber(int target) {
        target = Math.abs(target);
        int num = 0, n = 0;
        while (num < target || (num - target) % 2 == 1) // 没有到达（越过）终点，或者相距奇数
            num += ++n;
        return n;
    }
}

4.1106. 解析布尔表达式

/**
 * @author yangyiliy_liuyang
 * 2022/11/5
 * @version 1.0
 * 1106. 解析布尔表达式
 */
public class Main {
    public static void main(String[] args) {
        boolean b = parseBoolExpr("|(f,t)");
        System.out.println(b);
    }
    public static boolean parseBoolExpr(String expression) {
        /*
         */
        Deque<Character> st = new ArrayDeque<>();
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == '(' || c == ',') {
                continue;
            }
            if (c == ')') {
                List<Boolean> list = new ArrayList<>();
                while (st.peek() == 't' || st.peek() == 'f') {
                    list.add(st.poll() == 't' ? true : false);
                }
                char t = st.poll();
                boolean ans = list.get(0);
                if (t == '!') {
                    ans = !ans;
                }
                if (t == '&') {
                    for (int j = 1; j < list.size(); j++) {
                        ans &= list.get(j);
                    }
                }
                if (t == '|') {
                    for (int j = 1; j < list.size(); j++) {
                        ans |= list.get(j);
                    }
                }
                st.push(ans ? 't' : 'f');
            } else {
                st.push(c);
            }
        }
        return st.peek() == 't' ? true : false;
    }
}

5.1678. 设计 Goal 解析器

/**
 * @author yangyiliy_liuyang
 * 2022/11/6
 * @version 1.0
 * 1678. 设计 Goal 解析器
 */
public class Main {
    public static void main(String[] args) {
        String interpret = interpret("G()(al)");
        System.out.println(interpret);
        String interpret1 = interpret("(al)G(al)()()G");
        System.out.println(interpret1);
    }

    private static String interpret(String command) {
        String s = new String();
        char first = command.charAt(0);
        char next = command.charAt(0);
        int i = 0;
        while(i<command.length()-1){
            first = command.charAt(i);
            if (first == 'G') {
                s+="G";
                i++;
                continue;
            }
            next = command.charAt(i+1);
            if (next == ')') {
                s+='o';
                i+=2;
            }
            if (next == 'a' ) {
                s+="al";
                i+=4;
            }

        }
        if (command.charAt(command.length()-1)=='G'){
            s+="G";
        }
        return s;
    }
}

6.816. 模糊坐标

package Algorithm.LeetCode.ambiguousCoordinates;

import java.util.ArrayList;
import java.util.List;

/**
 * @author yangyiliy_liuyang
 * 2022/11/7
 * @version 1.0
 * 816. 模糊坐标
 * (123)
 * 1 23
 * 1 23  1 2.3
 * 12 3
 * 12 3  1.2 3
 */
public class Main {
    public static void main(String[] args) {
        List<String> strings = ambiguousCoordinates("(123)");
        System.out.println(strings);
    }

    private static List<String> ambiguousCoordinates(String s) {
        int n = s.length() - 2;
        List<String> res = new ArrayList<String>();
        s = s.substring(1, s.length() - 1);
        for (int l = 1; l < n; ++l) {
            List<String> lt = getPos(s.substring(0, l));
            if (lt.isEmpty()) {
                continue;
            }
            List<String> rt = getPos(s.substring(l));
            if (rt.isEmpty()) {
                continue;
            }
            for (String i : lt) {
                for (String j : rt) {
                    res.add("(" + i + ", " + j + ")");
                }
            }
        }
        return res;
    }

    public static List<String> getPos(String s) {
        List<String> pos = new ArrayList<String>();
        if (s.charAt(0) != '0' || "0".equals(s)) {
            pos.add(s);
        }
        for (int p = 1; p < s.length(); ++p) {
            if ((p != 1 && s.charAt(0) == '0') || s.charAt(s.length() - 1) == '0') {
                continue;
            }
            pos.add(s.substring(0, p) + "." + s.substring(p));
        }
        return pos;
    }
}

7.1684. 统计一致字符串的数目

package Algorithm.LeetCode.countConsistentStrings;

/**
 * @author yangyiliy_liuyang
 * 2022/11/8
 * @version 1.0
 * 1684. 统计一致字符串的数目
 */
public class Main {
    public static void main(String[] args) {
        int ab = countConsistentStrings("ab", new String[]{"ad", "bd", "aaab", "baa", "badab"});
        System.out.println(ab);
    }

    private static int countConsistentStrings(String allowed, String[] words) {
        int ans = words.length;
        for (int i = 0; i < words.length; i++) {
            //ToCharArray( )的用法，将字符串对象中的字符转换为一个字符数组。
            for (char c :
                    words[i].toCharArray()) {
                //contains（）,该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。
                //String.valueOf(char c) : 将 char 变量 c 转换成字符串
                if (!allowed.contains(String.valueOf(c))) {
                    ans--;
                    break;
                }
            }
        }
        return ans;
    }
}

8.764. 最大加号标志

package Algorithm.LeetCode.orderOfLargestPlusSign;

import java.util.Arrays;

/**
 * @author yangyiliy_liuyang
 * 2022/11/9
 * @version 1.0
 * 764. 最大加号标志
 * 输入: n = 5, mines = [[4, 2]]
 * 输出: 2
 */
public class Main {
    public static void main(String[] args) {
        int[][] mines = new int[][]{{4, 2}};
        int i = orderOfLargestPlusSign(5, mines);
        System.out.println(i);
    }

    private static int orderOfLargestPlusSign(int n, int[][] mines) {
        int[][] grid = new int[n][n];
        int ans = 0;
        for (int[] ints : grid) {
            Arrays.fill(ints, n);
        }
        for (int[] mine : mines) {
            grid[mine[0]][mine[1]] = 0;
        }
        for (int k = 0; k < n; k++) {
            int leftOne = 0, rightOne = 0, upOne = 0, downOne = 0;
            for (int i = 0, j = n - 1; i < n; i++, j--) {
                leftOne = (grid[k][i] == 0 ? 0 : leftOne + 1);
                grid[k][i] = Math.min(grid[k][i], leftOne);

                rightOne = (grid[k][j] == 0 ? 0 : rightOne + 1);
                grid[k][j] = Math.min(grid[k][j], rightOne);

                upOne = (grid[i][k] == 0 ? 0 : upOne + 1);
                grid[i][k] = Math.min(grid[i][k], upOne);

                downOne = (grid[j][k] == 0 ? 0 : downOne + 1);
                grid[j][k] = Math.min(grid[j][k], downOne);
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                //System.out.println(grid[i][j]);
                ans = Math.max(ans, grid[i][j]);
            }
        }
        return ans;
    }
}

9.864. 获取所有钥匙的最短路径

class Solution {
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int shortestPathAllKeys(String[] grid) {
        int m = grid.length, n = grid[0].length();
        int sx = 0, sy = 0;
        Map<Character, Integer> keyToIndex = new HashMap<Character, Integer>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i].charAt(j) == '@') {
                    sx = i;
                    sy = j;
                } else if (Character.isLowerCase(grid[i].charAt(j))) {
                    if (!keyToIndex.containsKey(grid[i].charAt(j))) {
                        int idx = keyToIndex.size();
                        keyToIndex.put(grid[i].charAt(j), idx);
                    }
                }
            }
        }

        Queue<int[]> queue = new ArrayDeque<int[]>();
        int[][][] dist = new int[m][n][1 << keyToIndex.size()];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                Arrays.fill(dist[i][j], -1);
            }
        }
        queue.offer(new int[]{sx, sy, 0});
        dist[sx][sy][0] = 0;
        while (!queue.isEmpty()) {
            int[] arr = queue.poll();
            int x = arr[0], y = arr[1], mask = arr[2];
            for (int i = 0; i < 4; ++i) {
                int nx = x + dirs[i][0];
                int ny = y + dirs[i][1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx].charAt(ny) != '#') {
                    if (grid[nx].charAt(ny) == '.' || grid[nx].charAt(ny) == '@') {
                        if (dist[nx][ny][mask] == -1) {
                            dist[nx][ny][mask] = dist[x][y][mask] + 1;
                            queue.offer(new int[]{nx, ny, mask});
                        }
                    } else if (Character.isLowerCase(grid[nx].charAt(ny))) {
                        int idx = keyToIndex.get(grid[nx].charAt(ny));
                        if (dist[nx][ny][mask | (1 << idx)] == -1) {
                            dist[nx][ny][mask | (1 << idx)] = dist[x][y][mask] + 1;
                            if ((mask | (1 << idx)) == (1 << keyToIndex.size()) - 1) {
                                return dist[nx][ny][mask | (1 << idx)];
                            }
                            queue.offer(new int[]{nx, ny, mask | (1 << idx)});
                        }
                    } else {
                        int idx = keyToIndex.get(Character.toLowerCase(grid[nx].charAt(ny)));
                        if ((mask & (1 << idx)) != 0 && dist[nx][ny][mask] == -1) {
                            dist[nx][ny][mask] = dist[x][y][mask] + 1;
                            queue.offer(new int[]{nx, ny, mask});
                        }
                    }
                }
            }
        }
        return -1;
    }
}

10.

package Algorithm.LeetCode.halvesAreAlike;

/**
 * @author yangyiliy_liuyang
 * 2022/11/11
 * @version 1.0
 * 1704. 判断字符串的两半是否相似
 */
public class Main {
    public static void main(String[] args) {
        boolean book = halvesAreAlike("book");
        System.out.println(book);
    }
    private static boolean halvesAreAlike(String s){
        String left = "";
        String right = "";
        int ansLeft=0;
        int ansright=0;
        for (int i = 0; i < s.length()/2; i++) {
            if(s.charAt(i)=='a'||s.charAt(i)=='e'||s.charAt(i)=='i'||s.charAt(i)=='o'||s.charAt(i)=='u'
                    ||s.charAt(i)=='A'||s.charAt(i)=='E'||s.charAt(i)=='I'||s.charAt(i)=='O'||s.charAt(i)=='U'){
                ansLeft++;
            }
        }
        for (int i = s.length()/2; i < s.length(); i++) {
            if(s.charAt(i)=='a'||s.charAt(i)=='e'||s.charAt(i)=='i'||s.charAt(i)=='o'||s.charAt(i)=='u'
                    ||s.charAt(i)=='A'||s.charAt(i)=='E'||s.charAt(i)=='I'||s.charAt(i)=='O'||s.charAt(i)=='U'){
                ansright++;
            }
        }

        return ansLeft==ansright;
    }
}

11.455. 分发饼干

package Algorithm.LeetCode.findContentChildren;

import java.util.Arrays;

/**
 * @author yangyiliy_liuyang
 * 2022/11/12
 * @version 1.0
 * 455. 分发饼干
 * 贪心算法
 */
public class Main {
    public static void main(String[] args) {
        int contentChildren = findContentChildren(new int[]{1, 2, 3}, new int[]{1, 1});
        System.out.println(contentChildren);
    }

    private static int findContentChildren(int[] g, int[] s) {
        int ans = 0;
        Arrays.sort(g);
        Arrays.sort(s);
        int i = 0;
        int j = 0;
        while (i < g.length && j < s.length) {
            if (s[j]>=g[i]){
                ans++;
                i++;
            }
            j++;
        }
        return ans;
    }
}

12.791. 自定义字符串排序

package Algorithm.LeetCode.custonSortString;

import java.util.HashSet;
import java.util.Set;

/**
 * @author yangyiliy_liuyang
 * 2022/11/13
 * @version 1.0
 * 791. 自定义字符串排序
 */
public class Main {
    public static void main(String[] args) {
        String s = customSortString("cba", "abcd");
        System.out.println(s);
    }
    private static String customSortString(String order,String s){
        StringBuffer ans = new StringBuffer();
        //记录已经被加入ans的索引值，留着加入ans后面
        Set<Integer> usedIndex = new HashSet<>();
        for (int i = 0; i < order.length(); i++) {
            for (int j = 0; j < s.length(); j++) {
                if (s.charAt(j)==order.charAt(i)) {
                    ans.append(s.charAt(j));
                    usedIndex.add(j);
                }
            }
        }
        for (int i = 0; i < s.length(); i++) {
            if (!usedIndex.contains(i)){
                ans.append(s.charAt(i));
            }
        }
        return ans.toString();
    }
}

13.376. 摆动序列

package Algorithm.LeetCode.wiggleMaxLength;

/**
 * @author yangyiliy_liuyang
 * 2022/11/14
 * @version 1.0
 * 376. 摆动序列
 */
public class Main {
    public static void main(String[] args) {
        int i = wiggleMaxLength(new int[]{1, 7, 4, 9, 2, 5});
        System.out.println(i);
    }

    private static int wiggleMaxLength(int[] nums) {
        //初始为1（默认最右面有一个峰值）
        int ans = 1;
        if (nums.length <= 1) {
            return nums.length;
        }
        //当前差值
        int curDiff = 0;
        int preDiff = 0;
        for (int i = 0; i < nums.length-1; i++) {
            curDiff = nums[i + 1] - nums[i];
            if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)){
                ans++;
                preDiff = curDiff;
            }
        }
        return ans;
    }
}