问题陈述是：
一个外星机器人威胁着宇宙，使用的光束将破坏所有算法知识。我们必须阻止它！
幸运的是，我们了解机器人的工作原理。它以强度为1的波束开始，它将运行一系列指令，该指令将按从左到右的顺序逐个执行。每条指令都属于以下两种类型之一：
C（对于＆＃34;充电＆＃34;）：使光束的强度加倍。 S（对于＆＃34;射击＆＃34;）：射出光束，造成的伤害等于光束的电流强度。 例如，如果机器人的程序是SCCSSC，机器人将在程序运行时执行以下操作：
射击光束，造成1点伤害。 给光束充电，使光束的强度加倍到2。 给光束充电，使光束的强度加倍到4。 射击光束，造成4点伤害。 射击光束，造成4点伤害。 给光束充电，将光束的强度增加到8。 在这种情况下，该计划将造成总共9次伤害。
宇宙的顶级算法专家已经开发出一种可以承受最大D伤害的盾牌。但机器人当前的程序可能会比运行时造成更大的伤害。
在机器人运行之前，宇宙总统已经自愿飞入太空攻击机器人的程序。总统可以攻击的唯一方法（没有机器人注意到）是通过交换两个相邻的指令。例如，总统可以通过交换第三和第四条指令使其成为SCSCSC来破解上述程序。这样可以将总损坏减少到7.然后，例如，总统可以再次破解程序使其成为SCSSCC，将损害减少到5，依此类推。
为防止机器人过于怀疑，总统不想太多次破解。什么是最小可能的黑客数量，如果可能的话，这将确保程序不会超过D总损害？
我的代码目前在交换字符串中的每个相邻字符后计算最小数量的黑客。然而，这并未涵盖产生损坏所需的最小数量的 N 的所有可能性＆lt; =屏蔽可以承受的损坏。 需要什么算法来完成所有可能性并找到所需的最少数量的黑客？我的代码在下面以供参考。
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Scanner;
public class Solution1 {
public static void main(String[] args) {
Scanner scan = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
int t = scan.nextInt(); // number of test cases
for (int i = 1; i <= t; i++) {
long maximumDamage = 0; // stores maximum damage that the shield can withstand
maximumDamage = scan.nextLong();
String program = "";
program = scan.next();
int numHacks = 0; // computes the number of hacks required
char[] programArr = program.toCharArray();
// computes the minimum number of hacks required
if (damageComputer(program) <= maximumDamage) {
System.out.println("Case #" + i + ": " + 0);
} else {
for (int j = 0; j < program.length() - 1; j++) {
char temp = 'a'; // stores one of the characters at position j
temp = programArr[j];
programArr[j] = programArr[j + 1];
programArr[j + 1] = temp;
numHacks++;
program = new String(programArr);
if (damageComputer(program) <= maximumDamage) {
System.out.println("Case #" + i + ": " + numHacks);
break;
}
}
}
}
}
// computes the total damage that a program will yield
public static long damageComputer(String program) {
long strength = 1; // Starts with 1 because initial strength of beam is 1
long damage = 0; // computes the current damage that the program will yield.
char[] programArr = program.toCharArray();
// computes the total damage
for (int i = 0; i < program.length() - 1; i++) {
if (programArr[i] == 'C') {
strength = strength * 2;
} else {
damage = damage + strength;
}
}
return damage;
}
}
编辑：适用于大多数测试用例，但在某些其他情况下陷入无限循环
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Scanner;
public class Solution1 {
public static void main(String[] args) {
Scanner scan = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
int t = scan.nextInt(); // number of test cases
for (int i = 1; i <= t; i++) {
long maximumDamage = 0; // stores maximum damage that the shield can withstand
maximumDamage = scan.nextLong();
String program = "";
String newProgram = "";
program = scan.next();
boolean hackCompleted = true;
int numHacks = 0; // computes the number of hacks required
char[] programArr = program.toCharArray();
// computes the minimum number of hacks required
if (damageComputer(program) <= maximumDamage) {
System.out.println("Case #" + i + ": " + 0);
} else {
programArr = program.toCharArray();
for (int k = 0; k < program.length() - 1; k++) {
newProgram = program;
for (int j = 0; j <= program.length() - 1; j++) {
char temp = 'a'; // stores one of the characters at position j
if (contains(newProgram, "CS") > 0) {
int containsIndex = contains(newProgram, "CS") - 1;
temp = programArr[containsIndex];
programArr[containsIndex] = programArr[containsIndex + 1];
programArr[containsIndex + 1] = temp;
numHacks++;
newProgram = new String(programArr);
} else {
hackCompleted = false;
}
newProgram = new String(programArr);
if (damageComputer(newProgram) <= maximumDamage) {
System.out.println("Case #" + i + ": " + numHacks);
hackCompleted = true;
break;
}
if (hackCompleted == true && j != 0) {
break;
}
}
if (hackCompleted == true) {
break;
}
numHacks = 0;
}
if (hackCompleted == false) {
System.out.println("Case #" + i + ": " + "IMPOSSIBLE");
}
}
}
}
// computes the total damage that a program will yield
public static long damageComputer(String program) {
long strength = 1; // Starts with 1 because initial strength of beam is 1
long damage = 0; // computes the current damage that the program will yield.
char[] programArr = program.toCharArray();
// computes the total damage
for (int i = 0; i < program.length(); i++) {
if (programArr[i] == 'C') {
strength = strength * 2;
} else {
damage = damage + strength;
}
}
return damage;
}
public static int contains(String s1, String s2) {
if(s1.length() < s2.length())
return -1;
int lastOccurrence = -1;
for (int i = 0; i < s1.length(); ) {
if (s1.startsWith(s2, i)) {
lastOccurrence = i + s2.length() - 1;
i = lastOccurrence + 1;
}
else {
++i;
}
}
return lastOccurrence;
}
}
最终更新问题已解决。请查看所选解决方案以及评论以获取指导。如果您想测试您的程序，测试用例就在这里。所有积分都归Google所有。
输入
6 1 CS 2 CS 1 SS 6 SCCSSC 2 CC 3 CSCSS
输出
案例＃1：1 案例＃2：0 案例＃3：不可能 案例＃4：2 案例＃5：0 案例＃6：5
答案 0 :(得分：0)
为了最大限度地减少黑客攻击次数 - 每次交换都应尽可能减少最大值造成的伤害，只有当我们交换最后一次出现的CS＆＃39;时才能达到最大值。子串，即用射击电荷交换电荷射击。
这是你的程序的一点点修改版本，它在2分钟内编写，所以我可能会错过一些边缘情况。
<form>
<input type="file" accept="image/*" name="" onchange="previewImage()">
<img id="preview">
</form>
<script>
function previewImage(){
var previewBox = document.getElementById("preview");
previewBox.src = URL.createObjectURL(event.target.files[0]);
}
</script>