2022-02-15每日刷题打卡

一、ACWing：899. 编辑距离

(1)题目描述

        

给定 nn 个长度不超过 1010 的字符串以及 mm 次询问，每次询问给出一个字符串和一个操作次数上限。

对于每次询问，请你求出给定的 nn 个字符串中有多少个字符串可以在上限操作次数内经过操作变成询问给出的字符串。

每个对字符串进行的单个字符的插入、删除或替换算作一次操作。

输入格式

第一行包含两个整数 nn 和 mm。

接下来 nn 行，每行包含一个字符串，表示给定的字符串。

再接下来 mm 行，每行包含一个字符串和一个整数，表示一次询问。

字符串中只包含小写字母，且长度均不超过 1010。

输出格式

输出共 mm 行，每行输出一个整数作为结果，表示一次询问中满足条件的字符串个数。

数据范围

1≤n,m≤10001≤n,m≤1000,

输入样例：

3 2
abc
acd
bcd
ab 1
acbd 2

输出样例：

1
3

(2)代码实现

        

import java.util.*;

public class Main
{
    static Scanner in = new Scanner(System.in);
    static int N = 15, M = 1010;
    static String strs[] = new String[M];
    static int f[][] = new int[N][N];

    static int f(String a, String b)
    {
        int la = a.length(), lb = b.length();
        char ca[] = new char[N], cb[] = new char[N];
        System.arraycopy(a.toCharArray(), 0, ca, 1, la);
        System.arraycopy(b.toCharArray(), 0, cb, 1, lb);
        for (int i = 0; i <= lb; i++) f[0][i] = i;
        for (int i = 0; i <= la; i++) f[i][0] = i;
        for (int i = 1; i <= la; i++)
            for (int j = 1; j <= lb; j++)
            {
                f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);
                f[i][j] = Math.min(f[i][j], f[i - 1][j - 1] + (ca[i] == cb[j] ? 0 : 1));
            }
        return f[la][lb];
    }

    public static void main(String args[])
    {
        int n = in.nextInt(), m = in.nextInt();
        for (int i = 0; i < n; i++) strs[i] = in.next();
        while (m-- > 0)
        {
            String s = in.next();
            int limit = in.nextInt(), ans = 0;
            for (int i = 0; i < n; i++)
                if (f(strs[i], s) <= limit) ans++;
            System.out.println(ans);
        }
    }

}

 二、ACWing:282. 石子合并

(1)问题描述

        

设有 NN 堆石子排成一排，其编号为 1，2，3，…，N1，2，3，…，N。

每堆石子有一定的质量，可以用一个整数来描述，现在要将这 NN 堆石子合并成为一堆。

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

例如有 44 堆石子分别为 1 3 5 2， 我们可以先合并 1、21、2 堆，代价为 44，得到 4 5 2， 又合并 1，21，2 堆，代价为 99，得到 9 2 ，再合并得到 1111，总代价为 4+9+11=244+9+11=24；

如果第二步是先合并 2，32，3 堆，则代价为 77，得到 4 7，最后一次合并代价为 1111，总代价为 4+7+11=224+7+11=22。

问题是：找出一种合理的方法，使总的代价最小，输出最小代价。

输入格式

第一行一个数 NN 表示石子的堆数 NN。

第二行 NN 个数，表示每堆石子的质量(均不超过 10001000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤N≤3001≤N≤300

输入样例：

4
1 3 5 2

输出样例：

22

(2)代码实现

        

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] S=new int[310];
        int[][] f=new int[310][310];
        for(int i=1;i<=n;i++){
            int a= in.nextInt();
            S[i]=a;
            S[i]+=S[i-1];
        }
        for(int len=2;len<=n;len++){
            for(int i=1;i+len-1<=n;i++){
                int j=i+len-1;
                f[i][j]=100000000;
                for(int k=i;k<j;k++){
                    f[i][j]=Math.min(f[i][j],f[i][k]+f[k+1][j]+S[j]-S[i-1]);
                }
            }
        }
        System.out.println(f[1][n]);
    }
}

 三、2019年蓝桥杯B组：第七题：外卖店优先级

(1)题目描述

        

“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。

每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。

如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果 优先级小于等于 3，则会被清除出优先缓存。

给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优 先缓存中。

【输入格式】

第一行包含 3 个整数 N、M 和 T。

以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。

【输出格式】

输出一个整数代表答案。

【样例输入】

2 6 6
1 1
5 2
3 1
6 2
2 1
6 2

【样例输出】

1

【样例解释】

6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6， 加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。

【评测用例规模与约定】

对于 80% 的评测用例，1≤ N,M,T ≤10000。
对于所有评测用例，1≤ N,M,T ≤100000，1≤ts≤T，1≤id ≤ N。

时间限制：1.0s

内存限制：512.0MB
 

(2)代码实现

        

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

public class TakeawayShopPriority外卖店优先级 {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		try {
			Set<Integer> set = new HashSet<Integer>();
			int N = input.nextInt();
			int M = input.nextInt();
			int T = input.nextInt();
			int[][] orders = new int[M][2];
			for (int i = 0; i < M; i++) {
				for (int j = 0; j < 2; j++) {
					orders[i][j] = input.nextInt();
				}
			}
			int[] priority = new int[N];
			int[] sign = new int[N];
			for (int i = 1; i <= T; i++) {
				for (int j = 0; j < M; j++) {
					if (orders[j][0] == i) {
						priority[orders[j][1] - 1] += 2;
						if (priority[orders[j][1] - 1] > 5 && !set.contains(orders[j][1] - 1)) {
							set.add(orders[j][1] - 1);
						}
						sign[orders[j][1] - 1] = 1;
					}
				}
				for (int j = 0; j < N; j++) {
					if (sign[j] == 0 && priority[j] > 0)
						priority[j]--;
					if (priority[j] <= 3) {
						set.remove(j);
					}
				}
				sign = new int[N];
			}
			System.out.println(set.size());
		} catch (Exception e) {
			input.close();
		}
	}
}