LeetCode刷题笔记简单题优秀题解集合(800~1200)

最新推荐文章于 2020-09-03 16:17:52 发布

XIIV13

最新推荐文章于 2020-09-03 16:17:52 发布

阅读量239

点赞数

分类专栏： LeetCode笔记

本文链接：https://blog.csdn.net/XIIV13/article/details/102988657

版权

LeetCode笔记专栏收录该内容

156 篇文章 1 订阅

订阅专栏

868. 二进制间距

给定一个正整数 N，找到并返回 N 的二进制表示中两个连续的 1 之间的最长距离。

如果没有两个连续的 1，返回 0 。

示例：
输入：22
输出：2
解释：
22 的二进制是 0b10110 。
在 22 的二进制表示中，有三个 1，组成两对连续的 1 。
第一对连续的 1 中，两个 1 之间的距离为 2 。
第二对连续的 1 中，两个 1 之间的距离为 1 。
答案取两个距离之中最大的，也就是 2 。

class Solution {
    public int binaryGap(int N) {
        int max = 0;
        int tmp = 0;
        while((N & 1) != 1) N >>= 1;
        while(N > 0){
            if((N & 1) == 1){
                max = Math.max(max, tmp);
                tmp = 0;
            }
            tmp++;
            N >>= 1;
        }
        return max;
    }
}

884. 两句话中的不常见单词

给定两个句子 A 和 B 。（句子是一串由空格分隔的单词。每个单词仅由小写字母组成。）

如果一个单词在其中一个句子中只出现一次，在另一个句子中却没有出现，那么这个单词就是不常见的。

返回所有不常用单词的列表。

您可以按任何顺序返回列表。

示例：
输入：A = “this apple is sweet”, B = “this apple is sour”
输出：[“sweet”,“sour”]

总结
“可以理解成拼接字符串A+B，然后返回拼接后的字符串中只出现过一次的单词。”
真是醍醐灌顶

class Solution {
    public String[] uncommonFromSentences(String A, String B) {
        Map<String, Integer> count = new HashMap();
        for (String word: A.split(" "))
            count.put(word, count.getOrDefault(word, 0) + 1);
        for (String word: B.split(" "))
            count.put(word, count.getOrDefault(word, 0) + 1);

        List<String> ans = new LinkedList();
        for (String word: count.keySet())
            if (count.get(word) == 1)
                ans.add(word);

        return ans.toArray(new String[ans.size()]);
    }
}

888. 公平的糖果交换

爱丽丝和鲍勃有不同大小的糖果棒：A[i] 是爱丽丝拥有的第 i 块糖的大小，B[j] 是鲍勃拥有的第 j 块糖的大小。

因为他们是朋友，所以他们想交换一个糖果棒，这样交换后，他们都有相同的糖果总量。（一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。）

返回一个整数数组 ans，其中 ans[0] 是爱丽丝必须交换的糖果棒的大小，ans[1] 是 Bob 必须交换的糖果棒的大小。

如果有多个答案，你可以返回其中任何一个。保证答案存在。

示例：
输入：A = [2], B = [1,3]
输出：[2,3]

Fastest Code
时空转移大法用到了极致

class Solution {
    public int[] fairCandySwap(int[] A, int[] B) {
        int sumA = 0;
        int sumB = 0;
        for(int a : A)
            sumA += a;
        
        int arr[] = new int[100001];
        for(int b : B){
            sumB += b;
            arr[b] = 1;
        }
        int diff = (sumA - sumB) / 2;

        for(int a : A){
            if((a-diff) >= 0 && (a-diff) <= 100000 && arr[a-diff] == 1)
                return new int[]{a, a-diff};
        }
        return null;
    }
}

Demo Code

class Solution {
    public int[] fairCandySwap(int[] A, int[] B) {
        Arrays.sort(A);
        Arrays.sort(B);
        int sumA = 0, sumB = 0;
        for(int i = 0; i < A.length; i++) 
            sumA += A[i];
        for(int i = 0; i < B.length; i++)        
            sumB += B[i];
        int[] res = new int[2];
        int diff = sumB - sumA;
        int le = 0, ri = B.length-1;
        for(int i = 0; i < A.length; i++) {
            for(int j = B.length-1; j >= 0; j--) {
                if(B[j] - A[i] == diff/2) {
                    res[0] = A[i];
                    res[1] = B[j];
                    break;
                }
                if(B[j] - A[i] < diff/2) continue;
            }
        }
        return res;
    }
}

892. 三维形体的表面积

在 N * N 的网格上，我们放置一些 1 * 1 * 1 的立方体。

每个值 v = grid[i][j] 表示 v 个正方体叠放在对应单元格 (i, j) 上。

请你返回最终形体的表面积。

总结
仔细想想还是很简单

class Solution {
	public int surfaceArea(int[][] grid) {
		int result=0;
		for (int i = 0; i < grid.length; i++) {
			for (int j = 0; j < grid[i].length; j++) {
				if (grid[i][j]!=0) 
					//假设每个v=grid[i][j]都是独立的。
					result+=grid[i][j]*4+2;
				//减去面贴在一起的情况
				if (i>0)
					result -= Math.min(grid[i-1][j], grid[i][j])*2;
				if (j>0)
					result -= Math.min(grid[i][j-1], grid[i][j])*2;
			}
		}
		return result;
	}
}

1071. 字符串的最大公因子

对于字符串 S 和 T，只有在 S = T + … + T（T 与自身连接 1 次或多次）时，我们才认定 “T 能除尽 S”。

返回字符串 X，要求满足 X 能除尽 str1 且 X 能除尽 str2。

示例 1：
输入：str1 = “ABCABC”, str2 = “ABC”
输出：“ABC”

示例 2：
输入：str1 = “LEET”, str2 = “CODE”
输出：""

class Solution {
    public String gcdOfStrings(String str1, String str2) {
        if (!(str1 + str2).equals(str2 + str1))
            return "";
        
        return str1.substring(0, gcd(str1.length(), str2.length()));
    }
    public int gcd(int a, int b) {
        return a == 0 ? b : gcd(b % a, a);
    }
}

1103. 分糖果 II

排排坐，分糖果。

我们买了一些糖果 candies，打算把它们分给排好队的 n = num_people 个小朋友。

给第一个小朋友 1 颗糖果，第二个小朋友 2 颗，依此类推，直到给最后一个小朋友 n 颗糖果。

然后，我们再回到队伍的起点，给第一个小朋友 n + 1 颗糖果，第二个小朋友 n + 2 颗，依此类推，直到给最后一个小朋友 2 * n 颗糖果。

重复上述过程（每次都比上一次多给出一颗糖果，当到达队伍终点后再次从队伍起点开始），直到我们分完所有的糖果。注意，就算我们手中的剩下糖果数不够（不比前一次发出的糖果多），这些糖果也会全部发给当前的小朋友。

返回一个长度为 num_people、元素之和为 candies 的数组，以表示糖果的最终分发情况（即 ans[i] 表示第 i 个小朋友分到的糖果数）。

示例：
输入：candies = 7, num_people = 4
输出：[1,2,3,1]
解释：
第一次，ans[0] += 1，数组变为 [1,0,0,0]。
第二次，ans[1] += 2，数组变为 [1,2,0,0]。
第三次，ans[2] += 3，数组变为 [1,2,3,0]。
第四次，ans[3] += 1（因为此时只剩下 1 颗糖果），最终数组变为 [1,2,3,1]。

class Solution {
    public int[] distributeCandies(int candies, int num_people) {
        int[] res = new int[num_people];
        int idx = 0, ex = 1;
        while(candies > 0) {
            if(idx >= num_people) {
                idx = 0;
                ex += num_people;
            }
            res[idx] += Math.min(candies, idx+ex);
            candies = Math.max(0, candies-idx-ex);
            idx++;
        }
        return res;
    }
}

class Solution {
    public int[] distributeCandies(int candies, int num_people) {
        int curr_give = 0;
        int[] res = new int[num_people];
        
        while (candies > 0) {
            res[curr_give % num_people] += Math.min(++curr_give, candies);
            candies -= curr_give;
        }
        
        return res;
    }
}

1128. 等价多米诺骨牌对的数量

给你一个由一些多米诺骨牌组成的列表 dominoes。

如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。

形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 ac 且 bd，或是 ad 且 bc。

在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。

示例：
输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]
输出：1

class Solution {
    public int numEquivDominoPairs(int[][] dominoes) {
        int[] map = new int[100];
        int res = 0;
        for(int i = 0; i < dominoes.length; i++){
            int m = dominoes[i][0];
            int n = dominoes[i][1];
            int k = m > n ? m * 10 + n : n * 10 + m;
            map[k] ++;
        }
        for(int i = 0; i < 100; i++)
            res += map[i] * (map[i] - 1) / 2;   // 取 n 里面有多少个 2

        return res;
    }
}

1170. 比较字符串最小字母出现频次

我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s 中（按字典序比较）最小字母的出现频次。

例如，若 s = “dcce”，那么 f(s) = 2，因为最小的字母是 “c”，它出现了 2 次。

现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。

示例：
输入：queries = [“cbd”], words = [“zaaaz”]
输出：[1]
解释：查询 f(“cbd”) = 1，而 f(“zaaaz”) = 3 所以 f(“cbd”) < f(“zaaaz”)。

class Solution {
    public int[] numSmallerByFrequency(String[] queries, String[] words) {
        int[] num = new int[12];

        for(int i = 0; i < words.length; i++)
            num[helper(words[i])]++;

        for(int i = 9; i >= 0; i--)
            num[i] += num[i+1];

        int[] res = new int[queries.length];
        for(int i = 0; i < queries.length; i++)
            res[i] = num[helper(queries[i])+1];

        return res;
    }
    public int helper(String s){
        int[] map = new int[26];
        for(char c : s.toCharArray())
            map[c-'a']++;

        for(int m : map){
           if(m != 0) return m;
        }
        return 0;
    }
}

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fair-candy-swap
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

XIIV13

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode刷题笔记简单题优秀题解集合(800~1200)

1071. 字符串的最大公因子对于字符串 S 和 T，只有在 S = T + … + T（T 与自身连接 1 次或多次）时，我们才认定 “T 能除尽 S”。返回字符串 X，要求满足 X 能除尽 str1 且 X 能除尽 str2。示例 1：输入：str1 = “ABCABC”, str2 = “ABC”输出：“ABC”示例 2：输入：str1 = “LEET”, str2 = “CO...
复制链接

扫一扫