【第一题】生成交替二进制字符串的最少操作数
分析：
方法一：双指针
方法二：直接和前一个字符异或，假如为1，则该位取反
注意，这里是字符串，不能更改，并且也不能进行位运算!!另外，是输出修改的最少操作数！所以不仅要跟0101…比较，还得跟1010…比较。
//因为要取到最小操作数，因此不仅要跟10101比较，还得跟01010比较。
//执行用时：3 ms, 在所有 Java 提交中击败了85.14% 的用户
//内存消耗：38.6 MB, 在所有 Java 提交中击败了34.72% 的用户
class Solution {
public int minOperations(String s) {
int res = 0,con = 0;
char[] ss = s.toCharArray();
char[] cc = new char[ss.length +1];
//构造0101:0(00)-1(01)-2(10)-3(11)-4(100)的末尾位为0-1-0-1-0
for(int i = 0;i < cc.length;i++){
if((i&1) == 0) cc[i] = '0';
else cc[i] = '1';
}
//与0101的情况比较
for(int i = 0;i < ss.length;i++){
if(ss[i] !=cc[i]) con++;
}
//与1010的情况进行比较
for(int i = 0;i < ss.length;i++){
if(ss[i] !=cc[i+1]) res++;
}
return Math.min(con,res);
}
}
//这个思路很优秀：偶数位比较，奇数位比较
class Solution {
public int minOperations(String s) {
int cnt1 = 0,cnt2 = 0;
for(int i = 0;i < s.length()-1;i++){
if(s.charAt(i)%2 != i%2){
cnt1++;
}else{
cnt2++;
}
}
return Math.min(cnt1,cnt2);
}
}
class Solution {
public int minOperations(String s) {
int dp0 = 0, dp1 = 0;
for (char item : s.toCharArray()) {
int zer0 = dp1 + (item == '0' ? 0 : 1);
int one = dp0 + (item == '1' ? 0 : 1);
dp0 = zer0;
dp1 = one;
}
return Math.min(dp0, dp1);
}
【第二题】玩筹码
分析：直接比较偶数和奇数的个数即可。
//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：36.1 MB, 在所有 Java 提交中击败了22.79% 的用户
class Solution {
public int minCostToMoveChips(int[] position) {
//chips = [1, 2, 2, 2, 3, 15, 23] 意味着位置1有1个筹码，位置2有3个筹码，同样位置3、15、23各有1个筹码。把所有筹码移动到一个位置，移动两步代价为0，那其实我就可以把所有“奇数位置”筹码移动到一个点A（奇数位置），且不必花费任何代价；同理，所有“偶数位置”的筹码移动到点B（偶数位置）也不需要任何代价。最终就是看A,B两点谁的筹码数多，把少的筹码移动到多的筹码的位置，每一个筹码的代价都是1
int num1 = 0,num2 = 0;
for(int i:position){
if(i % 2 == 0){
num1++;
}else{
num2++;
}
}
return Math.min(num1,num2);
}
}
【第三题】公平的糖果棒交换
分析：(sumB - sumA)/2 = gap
方法一：排序+双指针；
方法二：哈希表；gap = (sumB- sumA)/2，然后用哈希表在B中搜索，对于 B 中的任意一个数 y，只要 A 中存在一个数 x，满足x = y+(sumB- sumA)/2，那么 {x,y}即为一组可行解
方法三：二分查找
//哈希
class Solution{
public int[] fairCandySwap(int[] A,int[] B){
int sumA = Arrays.stream(A).sum();
int sumB = Arrays.stream(B).sum();
int delta = (sumA - sumB) / 2;
Set<Integer> rec = new HashSet<Integer>();
for(int num:A){
rec.add(num);
}
int[] ans = new int[2];
for(int y:B){
int x = y + delta;
if(rec.contains(x)){
ans[0] = x;
ans[1] = y;
break;
}
}
return ans;
}
}
//双指针
//执行用时：19 ms, 在所有 Java 提交中击败了43.06% 的用户
//内存消耗：40 MB, 在所有 Java 提交中击败了50.70% 的用户
class Solution {
public int[] fairCandySwap(int[] A, int[] B) {
int arr[] = new int[2];
int a = 0,b = 0;
for(int i:A){a += i;}
for(int j:B){b+=j;}
if(a == b){return arr;}
Arrays.sort(A);
Arrays.sort(B);
int pt1 = 0,pt2 = 0;
while(pt1 < A.length && pt2 < B.length){
if(A[pt1] - B[pt2] == (a-b)/2){
arr[0] = A[pt1];
arr[1] = B[pt2];
break;
}else if(A[pt1] - B[pt2] > (a-b)/2){
pt2++;
}else if(A[pt1] - B[pt2] < (a-b)/2){
pt1++;
}
}
return arr;
}
}
【第四题】检查整数及其两倍数是否存在
分析：直接用桶。注意，这里数组值可能是负数！
方法一：桶（这个方法有点麻烦，因为数组值可能是负数）；
方法二：集合、哈希；
方法三：二分查找；
方法三：双指针+排序；
//假如是正数的话，可以这么写
class Solution {
public boolean checkIfExist(int[] arr) {
if(arr.length == 2){
if(arr[0] / arr[1] == 2 || arr[1] / arr[0] == 2){
return true;
}else{
return false;
}
}
int ret[] = new int[arr.length * 4 + 1];
for(int i:arr){
if(arr[i] == 0){
arr[i] = 1;
arr[i * 2] = -1;
if(i % 2 == 0){arr[i % 2] == -1;}
}if(arr[i] == -1){
return true;
}else{
continue;
}
}
return false;
}
}
//集合
class Solution {
public boolean checkIfExist(int[] arr) {
HashSet<Integer> set = new HashSet<>();
for(int i:arr){
if(i % 2 == 0 && set.contains(i/2)){
return true;
}
if(set.contains(i*2)){
return true;
}
set.add(i);
}
return false;
}
}
【第五题】搜索插入位置
分析：有序+查找——>立即推 二分查找（有点插入排序的意思了）
//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：38.2 MB, 在所有 Java 提交中击败了38.32% 的用户
class Solution {
public int searchInsert(int[] nums, int target) {
int left = 0,right = nums.length -1;
while(left < nums.length && right >= 0 && left <= right){
int mid = (right + left)/2;
if(nums[mid] > target){
right = mid-1;
}else if(nums[mid] < target){
left = mid +1;
}else{
return mid;
}
}
return left;
}
}
【第六题】最小绝对差
分析：只需要找到minGap即可
方法一：单调队列；
方法二：先排序，再遍历（如果找到新的minGap，就把之前列表里的东西清空）
//执行用时：18 ms, 在所有 Java 提交中击败了91.25% 的用户
//内存消耗：49.3 MB, 在所有 Java 提交中击败了60.52% 的用户
class Solution {
public List<List<Integer>> minimumAbsDifference(int[] arr) {
List <List<Integer>> list = new ArrayList<>();
Arrays.sort(arr);
int minGap = Integer.MAX_VALUE;
for(int i= 0;i < arr.length-1;i++){
int gap = arr[i+1] - arr[i];
if(gap <= minGap){
minGap = Math.min(minGap,gap);
}
}
for(int i = 0;i < arr.length-1;i++){
if(arr[i+1] - arr[i] == minGap){
List<Integer> l = new ArrayList<>();
l.add(arr[i]);
l.add(arr[i+1]);
list.add(l);
}
}
return list;
}
}
class Solution {
public List<List<Integer>> minimumAbsDifference(int[] arr) {
Arrays.sort(arr);
List<List<Integer>> res = new LinkedList<>();
int min = 99999999;
for (int i = 1; i < arr.length; i++) {
int tmp = arr[i] - arr[i - 1];
// 找到新的最小差，清空原有结果
if (tmp < min) {
min = tmp;
res.clear();
}
// 如果是最小差，记录
if (tmp == min) {
List<Integer> item = new ArrayList<>(2);
item.add(arr[i - 1]);
item.add(arr[i]);
res.add(item);
}
}
return res;
}
}
【第七题】查询后的偶数和
分析：
class Solution{
public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
int[] ans = new int[A.length];
int sum = 0;//A数组中的偶数和
for (int i = 0; i < A.length; i++) {
if(A[i] % 2 == 0){
sum += A[i];
}
}
for (int i = 0; i < A.length; i++) {
int val = queries[i][0],index = queries[i][1];
if(A[index] % 2 == 0){//判断影响的值是否为偶数 是则删除
sum -= A[index];
}
A[index] += val;
if(A[index] % 2 == 0){//判断修改后的值是否为偶数 是则添加
sum += A[index];
}
ans[i] = sum;
}
return ans;
}
}
【第八题】公交站间的距离
分析：可用循环数组解决。
//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：38.3 MB, 在所有 Java 提交中击败了45.91% 的用户
class Solution {
public int distanceBetweenBusStops(int[] distance, int start, int destination) {
//不必区分谁为顺时针，谁为逆时针，直接比较大小即可。
//这里只需要计算d1，因为d2直接由sum - d1即可得到
int sum = 0;
for(int i :distance){
sum += i;
}
int d1 = 0;
int l = Math.min(start,destination);
int r = Math.max(start,destination);
for(int i = 0;i < distance.length;i++){
if(i >=l && i < r){
d1 += distance[i];
}
}
return Math.min(d1,sum - d1);
}
}
【第九题】数组形式的整数加法
分析：主要就是进位的处理
方法一：直接将K分解每一位，往数组上加即可，要是碰到进位再记录，加到下一位。
方法二：把进位的事情交给K
class Solution {
public List<Integer> addToArrayForm(int[] A, int K) {
int c = 0;
int len = A.length;
List<Integer> res = new ArrayList<>();
for(int i = len -1;i >= 0 || K!=0 || c!=0;i--){
int num = c+(i >=0 ?A[i]:0 + K%10);
res.add(0,num%10);
c = num / 10;
K/=10;
}
return res;
}
}
//执行用时：3 ms, 在所有 Java 提交中击败了98.23% 的用户
//内存消耗：40.4 MB, 在所有 Java 提交中击败了25.40% 的用户
class Solution{
public List<Integer> addToArrayForm(int[] A,int K){
int lastNum = K;
int i = A.length - 1;
LinkedList<Integer> list = new LinkedList<>();
//这里的控制条件必须是||，因为如果是&&的话，三位数向四位数的进位就无法完成。
while(i >= 0 || lastNum > 0){
if(i >= 0){lastNum += A[i];}
list.addFirst(lastNum % 10);
lastNum /=10;
i--;
}
return list;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
