A - First ABC 2
题目描述
给你一个字符串S，求出其中字符串ABC第一次出现的位置，如果没有，输出-1。
思路：模拟
public static void solve() throws IOException {
int n = readInt();
String s = readString();
boolean f = false;
for (int i = 0; i < s.length(); i++) {
if (i + 2 < s.length()) {
if (s.substring(i, i + 3).equals("ABC")) {
f = true;
printWriter.println(i + 1);
break;
}
}
}
if (!f) {
printWriter.println(-1);
}
}
B - Prefix and Suffix
题目描述
给你两个字符串S和T，如果S既是T的前缀又是T的后缀，则打印0； 如果S是T的前缀而不是后缀，则打印1； 如果S是T的后缀而不是前缀，则打印2； 如果S既不是T的前缀也不是后缀，则打印3。
思路：模拟
public static void solve() throws IOException {
int n = readInt(), m = readInt();
String s1 = readString(), s2 = readString();
boolean f1 = true;
for (int i = 0; i < n; i++) {
if (s1.charAt(i) != s2.charAt(i)) {
f1 = false;
break;
}
}
boolean f2 = true;
for (int i = m - 1, j = n - 1; j >= 0; j--, i--) {
if (s1.charAt(j) != s2.charAt(i)) {
f2 = false;
break;
}
}
if (f1 && f2) {
printWriter.println(0);
} else if (f1 && !f2) {
printWriter.println(1);
} else if (!f1 && f2) {
printWriter.println(2);
} else {
printWriter.println(3);
}
}
C - Festival
题目描述
一个王国举行N天的活动，其中M天会放烟花，现在请你求出，对于每一天的活动，下一次放烟花最近还有还多少天。
思路：模拟
public static void solve() throws IOException {
int n = readInt(), m = readInt();
int[] am = utils.nextIntArray(m);
for (int i = 1, j = 1; i <= n; i++) {
if (am[j] == i) {
printWriter.println(0);
j++;
} else {
printWriter.println(am[j] - i);
}
}
}
E - Product Development
题目描述
一家公司计划开发一种产品，该产品有 K K K个参数，初始参数值均为零，公司的目标是将所有参数值至少提高到 P P P。
现在有 N N N个发展计划，第 i i i个发展计划会使的 K K K个参数分别提高 A i , j A_{i,j} Ai,j个参数值，但是代价是 C i C_i Ci。
但是一个发展计划只能执行一次，请确定公司是否能实现目标，如果能，求出最小成本。
样例输入
4 3 5 5 3 0 2 3 1 2 3 3 2 4 0 1 0 1 4样例输出
9思路：动态规划+状态压缩
- 由于参数的个数时动态的，且数据较小，我们可以通过使用一个数
m的每一位 m i m_i mi来表示每个参数达到 m i m_i mi，dp[m]表示每个参数达到 m i m_i mi的最小代价，例如， m = 234 m=234 m=234，表示有 3 3 3个参数，dp[m]表示第 1 , 2 , 3 1,2,3 1,2,3个参数分别达到4,3,2参数值所需的最小代价(注意是从低位到高位)。- 而最终求的是所有参数均达到
P的最小代价，所以最终答案为dp[m]，m通过让 m i m_i mi均为P即可求得。
static long inf = utils.forceLong(1e14);
public static void solve() throws IOException {
int n = readInt(), k = readInt(), p = readInt(), m = 0;
long[] dp = new long[100005], c = new long[105];
int[][] a = new int[105][15];
for (int i = 1; i <= k; i++) m = m * 10 + p;// 不断重复 p,让 mi均为 p
for (int i = 1; i <= n; i++) {
c[i] = readInt();
for (int j = 1; j <= k; j++) {
a[i][j] = readInt();
}
}
// dp[x]数组定义：表示 k个参数状态为 x时的最小代价,最终求dp[m]即每一个产品都为 p的最小代价
Arrays.fill(dp, inf);
dp[0] = 0;
for (int i = 1; i <= n; i++) {// 物品
for (int j = m; j >= 0; j--) {// 价值
int[] w = new int[6];
for (int le = 1, ri = j; le <= k; le++, ri /= 10) {
// 如果出现 ri % 10 - a[i][le]小于等于 0，表示 j对于该参数无贡献，则为 0
if (ri % 10 - a[i][le] > 0) {
w[le] = ri % 10 - a[i][le];
}
}
// 如：对于样例,当i = 1 且 j = 203时,那么就需要知道 dp[000]的状态
// 最终可以得出dp[203][202][201][200][103][102][101][100][003][002][001] = 5
// 因为第一个数据只能满足第 3个参数为 2,1,0和第 2个参数为 0和第一个参数为 3,2,1,0的情况
int x = 0;// 用于表示需要 dp[x]的状态
for (int l = k; l >= 1; --l) x = x * 10 + w[l];
dp[j] = Math.min(dp[j], dp[x] + c[i]);// 01背包，选与不选
}
}
printWriter.println(dp[m] > utils.forceLong(1e11) ? -1 : dp[m]);
}
F - Vacation Query
题目描述
给你一个长度为 N N N且仅由0和1组成的字符串 S S S， S i S_i Si表示字符串 S S S的第 i i i个字符。现在给出Q个查询，每个查询由一个三元组 ( c , L , R ) (c, L, R) (c,L,R)组成，其中 c c c为查询类型
- 当 c = 1 c = 1 c=1 时，对于区间 L ≤ i ≤ R L \le i \le R L≤i≤R 的字符 S i S_i Si，如果 S i = 0 S_i=0 Si=0则将其修改为 1 1 1，否则修改为 0 0 0。
- 当 c = 2 c = 2 c=2时，求出区间 L ≤ i ≤ R L \le i \le R L≤i≤R 中连续 1 1 1的最大长度。
思路：线段树
- 维护最长前缀 1，最长后缀 1，区间最长 1 和 维护最长前缀 0，最长后缀 0，区间最长 0。
- 在
update函数中更新的重点在于原先维护的前/后缀连续1的个数，变为了前/后缀连续0的个数，区间的最长连续1的长度，变为了区间最长连续0的长度。
static class Tree {
int lazy;
int lMax, rMax, max;// 维护最长前缀 1，最长后缀 1，区间最长 1
int lMax0, rMax0, max0;// 维护最长前缀 0，最长后缀 0，区间最长 0
}
static int n, q;
static int[] nums;
static Tree[] tree;
public static void solve() throws IOException {
n = fr.readInt(); q = fr.readInt();
tree = new Tree[n << 2];
nums = new int[n];
Arrays.setAll(tree, p -> new Tree());
String s = fr.next();
for (int i = 0; i < s.length(); i++) {
nums[i] = s.charAt(i) - '0';
}
build(0, 0, n - 1);
while (q-- > 0) {
int c = fr.readInt(), a = fr.readInt() - 1, b = fr.readInt() - 1;
if (c == 1) {// update
update(0, 0, n - 1, a, b);
} else {// query
printWriter.println(query(0, 0, n - 1, a, b).max);
}
}
}
public static void build(int node, int l, int r) {
if (l == r) {
if (nums[l] == 1) {
tree[node].lMax = tree[node].rMax = tree[node].max = 1;
} else {
tree[node].lMax0 = tree[node].rMax0 = tree[node].max0 = 1;
}
return;
}
int mid = l + r >> 1, leftNode = node * 2 + 1, rightNode = node * 2 + 2;
build(leftNode, l, mid);
build(rightNode, mid + 1, r);
pushUp(node, l, r);
}
public static void update(int node, int l, int r, int s, int e) {
if (l >= s && r <= e) {
calc(node, l, r);
return;
}
pushDown(node, l, r);
int mid = l + r >> 1, leftNode = node * 2 + 1, rightNode = node * 2 + 2;
if (mid >= s) {
update(leftNode, l, mid, s, e);
}
if (mid < e) {
update(rightNode, mid + 1, r, s, e);
}
pushUp(node, l, r);
}
public static Tree query(int node, int l, int r, int s, int e) {
if (l >= s && r <= e) {
return tree[node];
}
pushDown(node, l, r);
int mid = l + r >> 1, leftNode = node * 2 + 1, rightNode = node * 2 + 2;
if (e <= mid) {// 只在左区间
return query(leftNode, l, mid, s, e);
} else if (s > mid) {// 只在右区间
return query(rightNode, mid + 1, r, s, e);
} else {
Tree le = query(leftNode, l, mid, s, e), ri = query(rightNode, mid + 1, r, s, e);
Tree res = new Tree();
int len1 = mid - l + 1, len2 = r - mid;
// 前缀 0
res.lMax0 = le.lMax0;
if (le.max0 == len1) res.lMax0 = len1 + ri.lMax0;
// 前缀 1
res.lMax = le.lMax;
if (le.max == len1) res.lMax = len1 + ri.lMax;
// 后缀 0
res.rMax0 = ri.rMax0;
if (ri.max0 == len2) res.rMax0 = len2 + le.rMax0;
// 后缀 1
res.rMax = ri.rMax;
if (ri.max == len2) res.rMax = len2 + le.rMax;
// 区间最长 0
res.max0 = Math.max(le.max0, ri.max0);
res.max0 = Math.max(res.max0, ri.lMax0 + le.rMax0);
// 区间最长 1
res.max = Math.max(le.max, ri.max);
res.max = Math.max(res.max, ri.lMax + le.rMax);
return res;
}
}
public static void pushDown(int node, int l, int r) {
if (tree[node].lazy != 0) {
int mid = l + r >> 1, leftNode = node * 2 + 1, rightNode = node * 2 + 2;
calc(leftNode, l, mid);
calc(rightNode, mid + 1, r);
tree[node].lazy = 0;
}
}
public static void calc(int node, int l, int r) {
// 交换前缀 0和前缀 1
int t1 = tree[node].lMax0;
tree[node].lMax0 = tree[node].lMax;
tree[node].lMax = t1;
// 交换后缀 0和后缀 1
int t2 = tree[node].rMax0;
tree[node].rMax0 = tree[node].rMax;
tree[node].rMax = t2;
// 交换区间最长 0和区间最长 1
int t3 = tree[node].max0;
tree[node].max0 = tree[node].max;
tree[node].max = t3;
tree[node].lazy ^= 1;
}
public static void pushUp(int node, int l, int r) {
int mid = l + r >> 1, leftNode = node * 2 + 1, rightNode = node * 2 + 2;
int len1 = mid - l + 1, len2 = r - mid;
// 前缀 0
tree[node].lMax0 = tree[leftNode].lMax0;
if (tree[leftNode].max0 == len1) {
tree[node].lMax0 = len1 + tree[rightNode].lMax0;
}
// 前缀 1
tree[node].lMax = tree[leftNode].lMax;
if (tree[leftNode].max == len1) {
tree[node].lMax = len1 + tree[rightNode].lMax;
}
// 后缀 0
tree[node].rMax0 = tree[rightNode].rMax0;
if (tree[rightNode].max0 == len2) {
tree[node].rMax0 = len2 + tree[leftNode].rMax0;
}
// 后缀 1
tree[node].rMax = tree[rightNode].rMax;
if (tree[rightNode].max == len2) {
tree[node].rMax = len2 + tree[leftNode].rMax;
}
// 区间最长 0
tree[node].max0 = Math.max(tree[leftNode].max0, tree[rightNode].max0);
tree[node].max0 = Math.max(tree[node].max0, tree[rightNode].lMax0 + tree[leftNode].rMax0);
// 区间最长 1
tree[node].max = Math.max(tree[leftNode].max, tree[rightNode].max);
tree[node].max = Math.max(tree[node].max, tree[rightNode].lMax + tree[leftNode].rMax);
}
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
