动态规划-字符交换-Java

package com.patience.interview.bytedance;

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

/**
 * 动态规划交换
 * @author Green.Gee
 * @date 2023/3/8 14:48
 * @email green.gee.lu@gmail.com
 */
public class DynamicPlan_7 {

    /**
     * 描述
     * 字符串S由小写字母构成，长度为n。
     *          定义一种操作，每次都可以挑选字符串中任意的两个相邻字母进行交换。
     *          询问在至多交换m次之后，字符串中最多有多少个连续的位置上的字母相同？
     *
     * 输入描述：
     * 第一行为一个字符串S与一个非负整数m。(1 <= |S| <= 1000, 1 <= m <= 1000000)
     *
     * 输出描述：
     * 一个非负整数，表示操作之后，连续最长的相同字母数量。
     * 示例1
     *   输入：
     *      abcbaa 2
     *
     *  输出：
     *     2
     * 说明：
     *      使2个字母a连续出现，至少需要3次操作。即把第1个位置上的a移动到第4个位置。
     *      所以在至多操作2次的情况下，最多只能使2个b或2个a连续出现。
     *
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        String [] str = line.split(" ");

        String s = str[0];
        int m = Integer.parseInt(str[1]);
        int res = 0;
        for (char ch = 'a'; ch <= 'z'; ch++) {
            List<Integer> position = new ArrayList<>();
            for (int i = 0; i < s.length(); i++) {
                if (ch == s.charAt(i)) {
                    position.add(i);
                }
            }

            if (position.size() < 2)
                continue;

            // 建立动态规划dp，一维装字母，另一维装位置，其维度与前面建立的positions的大小相等
            int size = position.size();
            int [][] dp = new int[size][size];

            //dp[i][j]表示，把位置positions[i],,,positions[j]的字母移动到一起所需要的最少移动次数
            for (int i = 0; i < size - 1; i++) {
                dp[i][i + 1] = position.get(i + 1) - position.get(i) - 1;
            }


            //当相同的字母在字符串中多次出现且不连续时，从两边网中间移动，保证移动次数最少。
            for (int len = 2; len < size; len++) {
                for (int left = 0; left < size - len; left++) {
                    int right = left + len;

                    dp[left][right] =
                            dp[left + 1][right - 1]
                            + position.get(right)
                            - position.get(left)
                            - 1
                            - (right - left - 1);

                }
            }

            for (int i = 0; i < size; i++) {
                for (int j = i + 1; j < size; j++) {
                    if (dp[i][j] <= m) {
                        res = Math.max(res, j - i + 1);
                    }
                }
            }
        }
        System.out.println(res);
    }
}