1.题目描述

2.知识点和思路

（1）贪心算法的基本思想
选择性质：在每一步中，选择当前最优的选项，不考虑未来的后果。
局部最优解：通过一系列局部最优选择，构建全局最优解。
不可回溯：一旦做出选择，不能回溯来改变之前的选择。
（2）贪心算法的例子
例子 1：找零问题
问题：给定一个金额，求用最少数量的硬币凑出该金额。假设硬币的面值有 1 元、5 元、10 元和 25 元。
贪心算法的思想：每次选择面值最大的硬币。
算法步骤：
选择当前金额下可用的最大面值的硬币。
从总金额中减去该硬币的面值。
重复上述步骤，直到总金额为 0。

import java.util.ArrayList;
import java.util.List;public class CoinChange {public static List<Integer> coinChange(int amount) {int[] coins = {25, 10, 5, 1};List<Integer> result = new ArrayList<>();for (int coin : coins) {while (amount >= coin) {amount -= coin;result.add(coin);}}return result;}public static void main(String[] args) {int amount = 41;List<Integer> result = coinChange(amount);System.out.println(result); // 预期输出: [25, 10, 5, 1]}
}

（3）贪心算法的例子2（太抽象了，暂时理解不了）
例子 2：活动选择问题
问题：给定一组活动，每个活动有开始时间和结束时间，要求选择尽可能多的互不重叠的活动。
贪心算法的思想：每次选择结束时间最早的活动，这样可以确保剩下的时间最大化。
算法步骤：
按活动结束时间排序。
选择第一个活动。
对于每个后续活动，如果其开始时间大于等于上一个选择活动的结束时间，则选择该活动。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class ActivitySelection {public static List<int[]> activitySelection(int[][] activities) {// 按活动结束时间排序Arrays.sort(activities, (a, b) -> a[1] - b[1]);List<int[]> result = new ArrayList<>();int[] lastActivity = activities[0];result.add(lastActivity);for (int i = 1; i < activities.length; i++) {if (activities[i][0] >= lastActivity[1]) {lastActivity = activities[i];result.add(lastActivity);}}return result;}public static void main(String[] args) {int[][] activities = {{1, 4},{3, 5},{0, 6},{5, 7},{3, 8},{5, 9},{6, 10},{8, 11},{8, 12},{2, 13},{12, 14}};List<int[]> result = activitySelection(activities);for (int[] activity : result) {System.out.println(Arrays.toString(activity));}// 预期输出: [[1, 4], [5, 7], [8, 11], [12, 14]]}
}

（4）返回可以通过分割得到的平衡字符串的 最大数量 。
我的思路是要返回平衡字符串的最大数量，说明分割的子字符串要足够的小，且保证字符串的两种字符的数量是想等的。

（5）字符串分割是处理和解析字符串的常见操作。
例子1：使用 split 方法
split 方法使用正则表达式将字符串分割成子字符串数组。

public class SplitExample {public static void main(String[] args) {String str = "apple,banana,cherry";String[] fruits = str.split(",");for (String fruit : fruits) {System.out.println(fruit);}// 预期输出:// apple// banana// cherry}
}

例子2:知道分割的位置，可以使用 substring 方法手动分割字符串。

public class SubstringExample {public static void main(String[] args) {String str = "apple-banana-cherry";int firstDash = str.indexOf("-");int secondDash = str.indexOf("-", firstDash + 1);String firstPart = str.substring(0, firstDash);String secondPart = str.substring(firstDash + 1, secondDash);String thirdPart = str.substring(secondDash + 1);System.out.println(firstPart);System.out.println(secondPart);System.out.println(thirdPart);// 预期输出:// apple// banana// cherry}
}

补充1：substring 方法在 Java 中用于从字符串中提取子字符串。它有两种主要的使用方式：
1）substring(int beginIndex)：返回从指定的起始索引（包含）开始到字符串末尾的子字符串。

public class SubstringExample1 {public static void main(String[] args) {String str = "apple-banana-cherry";// 从索引 6 开始到字符串末尾的子字符串String subStr1 = str.substring(6);System.out.println(subStr1); // 预期输出: banana-cherry}
}

2）substring(int beginIndex, int endIndex)：返回从指定的起始索引（包含）到结束索引（不包含）之间的子字符串。

public class SubstringExample2 {public static void main(String[] args) {String str = "apple-banana-cherry";// 从索引 6 开始到索引 12 (不包含) 的子字符串String subStr2 = str.substring(6, 12);System.out.println(subStr2); // 预期输出: banana}
}

补充2：str.indexOf(“-”) 方法在 Java 中用于查找字符串中第一次出现指定子字符串或字符的位置。它返回子字符串或字符在字符串中的索引（位置），如果找不到则返回 -1。

public class IndexOfExample {public static void main(String[] args) {String str = "apple-banana-cherry";// 找到第一个 '-' 的位置int firstDash = str.indexOf("-");System.out.println("The first '-' is at index: " + firstDash); // 预期输出: 5// 找到第二个 '-' 的位置，从第一个 '-' 之后开始搜索int secondDash = str.indexOf("-", firstDash + 1);System.out.println("The second '-' is at index: " + secondDash); // 预期输出: 12}
}

补充3：结合 indexOf 和 substring 使用

public class CombinedExample {public static void main(String[] args) {String str = "apple-banana-cherry";// 找到第一个 '-' 的位置int firstDash = str.indexOf("-");// 找到第二个 '-' 的位置，从第一个 '-' 之后开始搜索int secondDash = str.indexOf("-", firstDash + 1);// 提取第一个 '-' 之前的子字符串String firstPart = str.substring(0, firstDash);System.out.println("First part: " + firstPart); // 预期输出: apple// 提取第一个 '-' 和第二个 '-' 之间的子字符串String secondPart = str.substring(firstDash + 1, secondDash);System.out.println("Second part: " + secondPart); // 预期输出: banana// 提取第二个 '-' 之后的子字符串String thirdPart = str.substring(secondDash + 1);System.out.println("Third part: " + thirdPart); // 预期输出: cherry}
}

补充4：实现括号平衡检查

import java.util.Stack;public class BalancedParentheses {public static boolean isBalanced(String s) {Stack<Character> stack = new Stack<>();for (char c : s.toCharArray()) {if (c == '(' || c == '{' || c == '[') {stack.push(c);} else if (c == ')' || c == '}' || c == ']') {if (stack.isEmpty()) {return false;}char top = stack.pop();if (!isMatchingPair(top, c)) {return false;}}}return stack.isEmpty();}private static boolean isMatchingPair(char left, char right) {return (left == '(' && right == ')') ||(left == '{' && right == '}') ||(left == '[' && right == ']');}public static void main(String[] args) {String test1 = "{[()]}";String test2 = "{[(])}";String test3 = "{{[[(())]]}}";System.out.println(isBalanced(test1)); // 预期输出: trueSystem.out.println(isBalanced(test2)); // 预期输出: falseSystem.out.println(isBalanced(test3)); // 预期输出: true}
}

3.代码实现

先弄L,R计数器，还有一个平衡计数器。
在for循环里面（首先要满足将字符串变成字符数组，也就是s.toCharArrat())
对L、R字符进行计数，当cntL==cntR的时候，平衡字符串计数+1，cntL和cntR重新置0.

class Solution {public int balancedStringSplit(String s) {int cntL=0;int cntR=0;int BalanceCnt=0;for(char c:s.toCharArray()){if(c=='R'){cntR++;}else if(c=='L'){cntL++;}if(cntR==cntL){BalanceCnt++;cntR=0;cntL=0;}}return BalanceCnt;}
}