程序笔记

1.交替输出12A…5152Z

package 线程;


//两个线程，输出：12A 34B 56C ... 5152Z
//同步
public class synchronized控制输出 {
    public static void main(String[] args) {
        //同步锁，使用Object的wait和notifyAll方法
        Flag flag = new Flag();

        //之一，必须是锁对象flag调用wait和notify

        //new MyThread01(flag).start(); //线程1
        new Thread(new MyThread01(flag), "线程1").start();
        //new MyThread02(flag).start(); //线程
        new Thread(new MyThread02(flag), "线程2").start();
    }
}

// 同步锁
class Flag{
    public boolean flag = true;
}

//输出1-52
class MyThread01 implements Runnable{
    private Flag flag;
    public MyThread01(){

    }
    //传引用，与MyThread01中的flag为同一flag，实现同步
    public MyThread01(Flag flag){
        this.flag = flag;
    }

    public void run() {
        //true输出数字
        synchronized (this.flag){
            // 输出1 - 52
            for (int i = 1; i < 53; i++) {
                if(this.flag.flag){
                    System.out.print(i);
                    if (i%2 == 0){
                        //两次后变为false，不输出
                        this.flag.flag = false;
                        //唤醒
                        flag.notifyAll();
                    }
                }else {
                    try {
                        //等待
                        flag.wait();
                        //for运行了，故i-1
                        i--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

// 输出A-Z
class MyThread02 implements Runnable{
    private Flag flag;
    public MyThread02(){
    }
    //传引用，与MyThread01中的flag为同一flag，实现同步
    public MyThread02(Flag flag){
        this.flag = flag;
    }

    public void run() {
        //false输出字母
        synchronized (this.flag){
            for (int i = 0; i < 26; i++) {
                if(!this.flag.flag){
                    System.out.print((char)(i+65)+" ");
                    this.flag.flag = true;
                    //唤醒
                    flag.notifyAll();
                }else {
                    try {
                        //等待
                        flag.wait();
                        //for运行了，i-1
                        i--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

2.Shopee的办公室

package 算法;

import java.util.Scanner;

public class J01Shopee的办公室 {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        int n = sc.nextInt();
        int a[][] = new int[n][2];
        int map[][] = new int[x+1][y+1];
        for(int i=0; i<n; i++){
            a[i][0] = sc.nextInt();
            a[i][1] = sc.nextInt();
            map[a[i][0]][a[i][1]] = -1;
        }

        f(map, x, y, 0, 0);
        System.out.println(count);
    }

    static int count = 0;
    public static void f(int map[][], int x, int y, int nowx, int nowy){
        if (nowx == x && nowy == y){
            count++;
            return;
        }
        if (map[nowx][nowy] != -1){
            if (nowx < x) f(map,x,y,nowx+1, nowy);
            if (nowy < y) f(map,x,y,nowx, nowy+1);
        }

    }
}

3.万万没想到之聪明的编辑

package 算法;

import java.util.Scanner;

public class J02万万没想到之聪明的编辑 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] strings = new String[n];
        for (int i = 0; i < n; i++) {
            strings[i] = sc.next();
        }

        for (int i = 0; i < n; i++) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int j = 0; j < strings[i].length(); j++) {
                if (j==0 || j==1) stringBuilder.append(strings[i].charAt(j));
                else if (stringBuilder.length() == 2){
                    if ( f1(stringBuilder.charAt(stringBuilder.length()-1-1), stringBuilder.charAt(stringBuilder.length()-1), strings[i].charAt(j)) ){
                        stringBuilder.append(strings[i].charAt(j));
                    }
                }
                else if (stringBuilder.length() >= 3){
                    if ( f1(stringBuilder.charAt(stringBuilder.length()-1-1), stringBuilder.charAt(stringBuilder.length()-1), strings[i].charAt(j))
                            && f2(stringBuilder.charAt(stringBuilder.length()-1-2), stringBuilder.charAt(stringBuilder.length()-1-1),
                            stringBuilder.charAt(stringBuilder.length()-1), strings[i].charAt(j)) ){
                        stringBuilder.append(strings[i].charAt(j));
                    }
                }
            }
            strings[i] = stringBuilder.toString();
        }
        for (int i = 0; i < n; i++) {
            System.out.println(strings[i]);
        }
    }

    public static boolean f1(char c1, char c2, char c3){
        if (c1 == c2 && c2 == c3) return false;
        else return true;
    }
    public static boolean f2(char c1, char c2, char c3,char c4){
        if (c1 ==c2 && c3 == c4) return false;
        else return true;
    }
}

4. 无重复字符的最长子串

https://blog.csdn.net/djdjdjcux/article/details/104645003
我的博客

5.划分出所有单词并且记录每一个单词第一次出现的位置从一开始

package 算法;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class 划分出所有单词并且记录每一个单词第一次出现的位置从一开始 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        System.out.println(s);

        //自己实现
        // 作为是否在单词中的判断
        boolean inword = false;
        StringBuilder stringBuilder = new StringBuilder();
        //count作为map的键，记录出现的位置
        int count = 0;
        String word = "";
        Map<String, Integer> map = new LinkedHashMap<String, Integer>();
        for (int i = 0; i < s.length(); i++) {
            char now = s.charAt(i);
            //否是字母
            inword = isalp(now);
            if (inword == false){
                //不是字母，且stringBuilder中长度大于0
                if (stringBuilder.length()>=1){
                    word = stringBuilder.toString();
                    //如果不包含该单词再加入
                    if (!map.containsKey(word)) map.put(word, ++count);
                    //清空stringBuilder
                    stringBuilder.delete(0,stringBuilder.length());
                }
            }
            else{
                //是字母，加入到stringBuilder
                stringBuilder.append(s.charAt(i));
            }
        }
        //万一者人没有句号直接结束？？最后一个单词也不能忘
        if (stringBuilder.length( )>= 1){
            word = stringBuilder.toString();
            // 如果不包含该单词再加入
            if (!map.containsKey(word)) map.put(word, ++count);
            //清空stringBuilder
            stringBuilder.delete(0,stringBuilder.length());
        }
        System.out.println(map);
    }

    public static boolean isalp(char now){
        if ( (now>='A'&&now<='Z')||(now>='a'&&now<='z') ) return true;
        else return false;
    }
}

6.给出一个二进制串和一个整数k，k表示可以将串中的任意k个0换成1，求变换完后能形成的最大连续1串的长度

如
1 0 0 0 1 0 0 1 0 1 k = 3（初始串，给定k=3）
1 1 1 1 1 0 0 1 0 1 max = 5（一种解，替换第2~4个元素，但不是最优解）
1 0 0 0 1 1 1 1 1 1 max = 6（最优解，替换第6，7，9个0）
最优解法滑动窗口

	public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int k = sc.nextInt();

        //存0下标的队列，先进先出
        List<Integer> query = new LinkedList<Integer>();
        int zeroNum = 0;
        // 第一次和后面的分开，统一操作
        int p = -1;
        int max = 0;
        //i是滑动窗口中最左边的0，0左边可能还有1，所以l才是左边界
        //右边界就是j，会自动增长
        int l = 0;
        // 滑动窗口向右划动
        for (int i,j=0; j < n; j++) {
            // ==0时
            if (a[j] == 0){
                // 满时
                if (zeroNum >= k){

                    //已初始化，i向右滑动到下一个0处，此后都满足zeroNum >= k
                    if (p == 0){
                        i = query.remove(0);
                        query.add(j);
                        //计算左边界，0左边可能还有1，所以l才是左边界
                        l = i;
                        while(l>=1 && a[l-1] == 1) l--;
                    }
                    //未初始化，先初始化，不要第一个0，并且重新执行本次循环
                    else if (p == -1){
                        query.remove(0);
                        p = 0;
                        j--;
                    }

                }
                // 队列中0个数小于k，可以直接添加
                else {
                    zeroNum++;
                    query.add(j);
                }

            }
            // 计算最长
            max = Math.max(max, j-l+1);
        }
        System.out.println(max);
    }

运行结果