目录
1.leetcode301删除无效的括号
class Solution {
// 来自leetcode投票第一的答案，实现非常好，我们来赏析一下
public static List<String> removeInvalidParentheses(String s) {
List<String> ans = new ArrayList<>();
remove(s, ans, 0, 0, new char[] { '(', ')' });
return ans;
}
// modifyIndex <= checkIndex
// 只查s[checkIndex....]的部分，因为之前的一定已经调整对了
// 但是之前的部分是怎么调整对的，调整到了哪？就是modifyIndex
// 比如：
// ( ( ) ( ) ) ) ...
// 0 1 2 3 4 5 6
// 一开始当然checkIndex = 0，modifyIndex = 0
// 当查到6的时候，发现不对了，
// 然后可以去掉2位置、4位置的 )，都可以
// 如果去掉2位置的 ), 那么下一步就是
// ( ( ( ) ) ) ...
// 0 1 2 3 4 5 6
// checkIndex = 6 ，modifyIndex = 2
// 如果去掉4位置的 ), 那么下一步就是
// ( ( ) ( ) ) ...
// 0 1 2 3 4 5 6
// checkIndex = 6 ，modifyIndex = 4
// 也就是说，
// checkIndex和modifyIndex，分别表示查的开始 和 调的开始，之前的都不用管了 par ( )
public static void remove(String s, List<String> ans, int checkIndex, int deleteIndex, char[] par) {
for (int count = 0, i = checkIndex; i < s.length(); i++) {
if (s.charAt(i) == par[0]) {
count++;
}
if (s.charAt(i) == par[1]) {
count--;
}
// i check计数<0的第一个位置
if (count < 0) {
for (int j = deleteIndex; j <= i; ++j) {
// 比如
if (s.charAt(j) == par[1] && (j == deleteIndex || s.charAt(j - 1) != par[1])) {
remove(
s.substring(0, j) + s.substring(j + 1, s.length()),
ans, i, j, par);
}
}
return; //删除第一个不合法的。 直接return
}
}
String reversed = new StringBuilder(s).reverse().toString();
if (par[0] == '(') {
remove(reversed, ans, 0, 0, new char[] { ')', '(' });
} else {
ans.add(reversed);
}
}
}2.leetcode45跳跃游戏 II
/**
O(N)
O(1)
*/
class Solution {
public static int jump(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int step = 0;
int cur = 0;
int next = 0;
for (int i = 0; i < arr.length; i++) {
if (cur < i) {
step++;
cur = next;
}
next = Math.max(next, i + arr[i]);
}
return step;
}
}3.leetcode517超级洗衣机
class Solution {
public int findMinMoves(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int size = arr.length;
int sum = 0;
for (int i = 0; i < size; i++) {
sum += arr[i];
}
if (sum % size != 0) {
return -1;
}
int avg = sum / size;
int leftSum = 0;
int ans = 0;
for (int i = 0; i < arr.length; i++) {
int leftRest = leftSum - i * avg;
int rightRest = (sum - leftSum - arr[i]) - (size - i - 1) * avg;
if (leftRest < 0 && rightRest < 0) {
ans = Math.max(ans, Math.abs(leftRest) + Math.abs(rightRest));
} else {
ans = Math.max(ans, Math.max(Math.abs(leftRest), Math.abs(rightRest)));
}
leftSum += arr[i];
}
return ans;
}
}4.leetcode407接雨水 II
class Solution {
public static class Node {
public int value;
public int row;
public int col;
public Node(int v, int r, int c) {
value = v;
row = r;
col = c;
}
}
public static int trapRainWater(int[][] heightMap) {
if (heightMap == null || heightMap.length == 0 || heightMap[0] == null || heightMap[0].length == 0) {
return 0;
}
int N = heightMap.length;
int M = heightMap[0].length;
boolean[][] isEnter = new boolean[N][M];
PriorityQueue<Node> heap = new PriorityQueue<>((a, b) -> a.value - b.value);
for (int col = 0; col < M - 1; col++) {
isEnter[0][col] = true;
heap.add(new Node(heightMap[0][col], 0, col));
}
for (int row = 0; row < N - 1; row++) {
isEnter[row][M - 1] = true;
heap.add(new Node(heightMap[row][M - 1], row, M - 1));
}
for (int col = M - 1; col > 0; col--) {
isEnter[N - 1][col] = true;
heap.add(new Node(heightMap[N - 1][col], N - 1, col));
}
for (int row = N - 1; row > 0; row--) {
isEnter[row][0] = true;
heap.add(new Node(heightMap[row][0], row, 0));
}
int water = 0;
int max = 0;
while (!heap.isEmpty()) {
Node cur = heap.poll();
max = Math.max(max, cur.value);
int r = cur.row;
int c = cur.col;
// 上
if (r > 0 && !isEnter[r - 1][c]) {
water += Math.max(0, max - heightMap[r - 1][c]);
isEnter[r - 1][c] = true;
heap.add(new Node(heightMap[r - 1][c], r - 1, c));
}
// 下
if (r < N - 1 && !isEnter[r + 1][c]) {
water += Math.max(0, max - heightMap[r + 1][c]);
isEnter[r + 1][c] = true;
heap.add(new Node(heightMap[r + 1][c], r + 1, c));
}
// 左
if (c > 0 && !isEnter[r][c - 1]) {
water += Math.max(0, max - heightMap[r][c - 1]);
isEnter[r][c - 1] = true;
heap.add(new Node(heightMap[r][c - 1], r, c - 1));
}
// 右
if (c < M - 1 && !isEnter[r][c + 1]) {
water += Math.max(0, max - heightMap[r][c + 1]);
isEnter[r][c + 1] = true;
heap.add(new Node(heightMap[r][c + 1], r, c + 1));
}
}
return water;
}
}5.面试题 08.14. 布尔运算
class Solution {
public int countEval(String express, int desired) {
if (express == null || express.equals("")) {
return 0;
}
char[] exp = express.toCharArray();
int N = exp.length;
Info[][] dp = new Info[N][N];
Info allInfo = func(exp, 0, exp.length - 1, dp);
return desired == 1 ? allInfo.t : allInfo.f;
}
public class Info {
public int t; //为true的方法数
public int f; //为false的方法数
public Info(int tr, int fa) {
t = tr;
f = fa;
}
}
// 限制:
// L...R上，一定有奇数个字符
// L位置的字符和R位置的字符，非0即1，不能是逻辑符号！
// 返回str[L...R]这一段，为true的方法数，和false的方法数
public Info func(char[] str, int L, int R, Info[][] dp) {
if (dp[L][R] != null) {
return dp[L][R];
}
int t = 0;
int f = 0;
if (L == R) {
t = str[L] == '1' ? 1 : 0;
f = str[L] == '0' ? 1 : 0;
} else { // L..R >=3
// 每一个种逻辑符号，split枚举的东西
// 都去试试最后结合
for (int split = L + 1; split < R; split += 2) {
Info leftInfo = func(str, L, split - 1, dp);
Info rightInfo = func(str, split + 1, R, dp);
int a = leftInfo.t;
int b = leftInfo.f;
int c = rightInfo.t;
int d = rightInfo.f;
switch (str[split]) {
case '&':
t += a * c;
f += b * c + b * d + a * d;
break;
case '|':
t += a * c + a * d + b * c;
f += b * d;
break;
case '^':
t += a * d + b * c;
f += a * c + b * d;
break;
}
}
}
dp[L][R] = new Info(t, f);
return dp[L][R];
}
}6.剑指 Offer 62. 圆圈中最后剩下的数字
/**
公式： 前 = （后 + m - 1） % i + 1
*/
// 提交直接通过
// 给定的编号是0~n-1的情况下，数到m就杀
// 返回谁会活？
public int lastRemaining1(int n, int m) {
return getLive(n, m) - 1;
}
// 课上题目的设定是，给定的编号是1~n的情况下，数到m就杀
// 返回谁会活？
public static int getLive(int n, int m) {
if (n == 1) {
return 1;
}
//公式：前 = （后 + m - 1） % i + 1 ；
return (getLive(n - 1, m) + m - 1) % n + 1;
}
class Solution {
public int lastRemaining(int n, int m) {
int ans = 1;
int r = 1;
while (r <= n) {
ans = (ans + m - 1) % (r++) + 1;
}
return ans - 1;
}
}下一阶段
7.leetcode7整数反转
/**
时间复杂度O(log|x|)
空间复杂度O(1)
//为什么要除以10
// 2147483647 2的31次方-1
// 2147483650 此时溢出
// 那么我们可以直接从 最大数的1/10处，开始判断
*/
class Solution {
public int reverse(int x) {
int rev = 0;
while (x != 0) {
if (rev < Integer.MIN_VALUE / 10 || rev > Integer.MAX_VALUE / 10) {
return 0;
}
int digit = x % 10;
x /= 10;
rev = rev * 10 + digit;
}
return rev;
}
}8.leetcode9回文数
/**
时间复杂度O(log n)
空间复杂度O(1)
*/
class Solution {
public boolean isPalindrome(int x) {
// 特殊情况：
// 如上所述，当 x < 0 时，x 不是回文数。
// 同样地，如果数字的最后一位是 0，为了使该数字为回文，
// 则其第一位数字也应该是 0
// 只有 0 满足这一属性
if (x < 0 || (x % 10 == 0 && x != 0)) {
return false;
}
int revertedNumber = 0;
while (x > revertedNumber) {
revertedNumber = revertedNumber * 10 + x % 10;
x /= 10;
}
// 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
// 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
// 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
return x == revertedNumber || x == revertedNumber / 10;
}
}9.leetcode14最长公共前缀
/**
纵向扫描
时间复杂度O(m n)
空间复杂度O( 1 )
*/
class Solution {
public String longestCommonPrefix(String[] strs) {
if (strs == null || strs.length == 0) {
return "";
}
int length = strs[0].length(); //第一个字符串的长度
int count = strs.length; //字符串的个数
for (int i = 0; i < length; i++) { //第一个字符串的长度
char c = strs[0].charAt(i); //第一个字符
for (int j = 1; j < count; j++) { // 开始后面字符串的比对
if (i == strs[j].length() || strs[j].charAt(i) != c) {
return strs[0].substring(0, i);
}
}
}
return strs[0];
}
}
10.leetcode16最接近的三数之和
/**
时间复杂度O( N的平方 )
空间复杂度O( log N )
*/
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);
int n = nums.length;
int best = 10000000;
// 枚举 a
for (int i = 0; i < n; ++i) {
// 保证和上一次枚举的元素不相等
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
// 使用双指针枚举 b 和 c
int j = i + 1, k = n - 1;
while (j < k) {
int sum = nums[i] + nums[j] + nums[k];
// 如果和为 target 直接返回答案
if (sum == target) {
return target;
}
// 根据差值的绝对值来更新答案
if (Math.abs(sum - target) < Math.abs(best - target)) {
best = sum;
}
if (sum > target) {
// 如果和大于 target，移动 c 对应的指针
int k0 = k - 1;
// 移动到下一个不相等的元素
while (j < k0 && nums[k0] == nums[k]) {
--k0;
}
k = k0;
} else {
// 如果和小于 target，移动 b 对应的指针
int j0 = j + 1;
// 移动到下一个不相等的元素
while (j0 < k && nums[j0] == nums[j]) {
++j0;
}
j = j0;
}
}
}
return best;
}
}
扫一扫
490
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
