BJTU OJ题
Problem D. 等差数列
给定一个长度为n的整数数列A，求最少删除几个数才能使得A变成等差数列。
注：至少需要有三个数才能构成等差数列。
输入数据
第一行输入一个整数n(1≤n≤233)。
第二行输入n个整数，依次为A1,A2,…,An(−105 ≤Ai≤ 105)。
输出数据
若能变成等差数列则输出最少删除数，否则输出-1。
样例输入
5
1 2 3 3 4
样例输出
1
分析
考虑到233的数组大小，可直接三重for暴力循环解决。（如数据较大后，则选用动态规划、哈希表）
代码如下：
import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner s = new Scanner(new BufferedInputStream(System.in));
int n = s.nextInt();
int[] a = new int[n];
for (int i=0;i<n;i++){
a[i] = s.nextInt();
}
//res取每次新出的等差数列长度与先前最长等差数列长度两者中的长者
//结果表示最长等差数列的长度
int res = 0;
//两边for循环
for (int i=0;i<n-2;i++){
for (int j=i+1;j<n-1;j++){
int d = a[i] - a[j];
int cur = j;
int count = 2;
for (int k=j+1;k<n;k++){
if (a[cur]-a[k]==d){
++count;
cur = k;
}
}
res = Math.max(res,count);
}
}
//-1的判定
if (n<3||res==2){ System.out.println("-1"); }
else{ System.out.println(n-res);}
}
}
Problem E. 多项式的值
给定一个n次多项式f(x)= ∑ni= a[i]*xi以及一个整数c。
求f© mod 114514 。
输入数据
第一行输入两个整数n,c(1≤n,c≤105)。
第二行输入n+1个整数，依次为a0,a1,a2,…,an(1≤ai≤105)。
输出数据
一个整数，为f© mod 114514 。
样例输入
3 1
1 1 1 1
样例输出
4
分析：Java的BigInteger，yyds！
毫无疑问，这是个大数问题。作为累加式，其单个子式理论最大值为105*(100000100000)。
要点：每次取余；幂值要保存;采用Horner范式
范式如下图：
代码如下：
import java.io.InputStreamReader;
import java.math.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(new InputStreamReader(System.in));
int n = s.nextInt();
BigInteger c = s.nextBigInteger();
BigInteger d = new BigInteger("114514");
BigInteger[] a = new BigInteger[n+1];
for (int i=0;i<=n;i++){
a[i] = s.nextBigInteger();
}
BigInteger b = new BigInteger("0");
//Horner范式
for (int i=0;i<=n;++i){
b = (((b.multiply(c)).remainder(d)).add(a[n-i])).remainder(d);
}
System.out.println(b);
}
}
以下是我最初始的思路，但并未AC，显示为WA。
import java.io.InputStreamReader;
import java.math.*;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(new InputStreamReader(System.in));
int n = s.nextInt();
BigInteger c = s.nextBigInteger();
BigInteger f = new BigInteger("1");
BigInteger d = new BigInteger("114514");
BigInteger[] a = new BigInteger[n+1];
BigInteger b = new BigInteger("0");
//先将a[0]项单独列出来
a[0] = s.nextBigInteger();
b = (b.add(a[0])).remainder(d);
for (int i=1;i<n+1;i++){
a[i] = s.nextBigInteger();
//x^c的表达式，用f保存上一次的值，若不保存，会TLE
f = (f.multiply(c)).remainder(d);//取余
//a[i]*f的表达式，用b表示累加结果
b = b.add((f.multiply(a[i])).remainder(d));//取余
}
System.out.println(b);
}
}
在此过程中出现的一些小问题：
//数值溢出
public class Main {
public static void main(String[] args){
long a;
long b;
long d;
a =(100000*114513)%114514;
d =(long)100000*114513;
b =d%114514;
System.out.println(a);//-1122
System.out.println(b);//14514
}
}
a值为负，因100000*114514溢出
Problem F. 单词统计
给定一个长度为n的字符串S，和一个长度为m的单词W，求S中有多少个子序列等于W。
字符串的子序列指从原序列中删除若干字符后形成的新字符串。
如字符串ABC的所有子序列为A,B,C,AB,AC,BC,ABC以及空串。
输入数据
输入有3行，第一行包括两个整数n(1≤n≤105),m(1<=m<=3) ，分别表示字符串和单词的长度。
第二行为一个长度为n的字符串S。
第三行为一个长度为m的单词W。
S,W仅大由写字母组成。
输出数据
一个整数，表示S的子序列中所给单词出现的次数。
样例输入
10 3
AAABBBCCCC
ABC
样例输出
36
分析：子序列只删除部分字符或不删除且顺序不变。以下是最初我不考虑顺序时的Code：
import java.io.BufferedInputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static String Map1(String h) {
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < h.length(); i++) {
if (map.get(h.charAt(i)) != null) {
map.put(h.charAt(i), map.get(h.charAt(i)) + 1);
}
else {
map.put(h.charAt(i), 1);
}
}
return map.values().toString();//形式为[3, 3, 4] 有空格
}
public static String Map2(String g) {
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < g.length(); i++) {
if (map.get(g.charAt(i)) != null) {
map.put(g.charAt(i), map.get(g.charAt(i)) + 1);
} else {
map.put(g.charAt(i), 1);
}
}
return map.keySet().toString();//形式为[A, B, C] 有空格
}
//阶乘m!
public static int Factorial1(int num) {
int a = 1;
for (int i = num; i >=1; i--) {
a *= i;
}
return a;
}
//阶乘(n-m)!
public static int Factorial2(int num, int m) {
int a = 1;
for (int i = num; i >= num - m + 1; i--) {
a *= i;
}
return a;
}
//去除map的keyset和value的非数值部分
public static String toChar(String a) {
a = a.replaceAll(",", "");
a = a.replaceAll("]", "");
a = a.replaceAll(" ", "");
a = a.substring(1);
return a;
}
public static void main(String[] args){
Scanner s = new Scanner(new BufferedInputStream(System.in));
int n = s.nextInt();
int m = s.nextInt();
Long sum = (long)1;
s.nextLine();
String a = s.nextLine();
String b = s.nextLine();
a = a.substring(0,a.lastIndexOf(b.charAt(m-1))+1);
char[] c = toChar(Map1(a)).toCharArray();
char[] d = toChar(Map1(b)).toCharArray();
String e = toChar(Map2(a));
String f = toChar(Map2(b));
Long[] Count = new Long[f.length()];
for (int i = 0; i < f.length(); i++) {
for (int j = 0; j < e.length(); j++) {
if (f.charAt(i) == e.charAt(j)) {
//字符转换为数值
Count[i] = (long)(Factorial2(c[j]-'0',d[i]-'0') / (Factorial1(d[i]-'0'))) ;
sum *= Count[i];
}
}
}
System.out.println(sum);
}
}
后来考虑顺序，采用动态规划（这道题数据小，在此兼顾数据量大的情况，以下参考leetcode：最长子序列
创建二维数组dp，其中dp[i][j]表示在a[i,end]（表示字符串a从i到a.length-1的模式串，下同）的子序列中b[j,end]出现的次数
考虑动态规划的边界情况：
1.j=m：此时b[i,end]为空串，则任意的dp[i][m]皆=1；
2.i=n & j<m：此时a[i,end]为空串，此时易得任意dp[n][j]=0；
当i<n & h<m，考虑dp[i][j]：
1.当a[i] = b[j]时，dp[i][j]由两部分组成
A:如a[i]与b[j]匹配，则考虑 b[j+1,end]作为a[i+1，end]的子序列，子序列数为dp[i+1][j+1]；
B:如果 a[i]不和 b[j]匹配，则考虑 b[j,end] 作为 a[i+1,end]的子序列，子序列数为 dp[i+1][j]。
则此时dp[i][j]=dp[i+1][j+1]+dp[i+1][j]。
2.当a[i] != b[j]时，此时a[i]不能与b[j]匹配，则只考虑b[j,end]作为a[i+1,end]的子序列，子序列数为dp[i][j] = dp[i+1][j]。
由上得状态转移方程：
最终计算得到的dp[0][0]即在a的子序列中b出现的个数。
import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner s = new Scanner(new BufferedInputStream(System.in));
int n = s.nextInt();
int m = s.nextInt();
s.nextLine();
String a = s.nextLine();
String b = s.nextLine();
int[][] dp = new int[n+1][m+1];
for (int i = 0; i <= n; i++) {
dp[i][m] = 1;
}
for (int i = n - 1; i >= 0; i--) {
char aChar = a.charAt(i);
for (int j = m - 1; j >= 0; j--) {
char bChar = b.charAt(j);
if (aChar == bChar) {
dp[i][j] = dp[i + 1][j + 1] + dp[i + 1][j];
}
else {
dp[i][j] = dp[i + 1][j];
}
}
}
System.out.println(dp[0][0]);
}
}
At last：
public class Main {
public static void main(String[] args){
System.out.println("Hello, world!");
}
}
以此作结，算CS生涯的启航吧，往后余生，唯行而已。
185
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
