今天周賽時間沒趕上，有高中學生參觀實驗室，我代表安卓組給他們介紹我們的項目。
忙完都11:40了，原本都不想做了，一看第一題很簡單，然後一做就停不下來了···
5255. 奇數值單元格的數目
5255. 奇數值單元格的數目 顯示英文描述
用戶通過次數948
用戶嘗試次數974
通過次數970
提交次數1244
題目難度Easy
給你一個 n 行 m 列的矩陣，最開始的時候，每個單元格中的值都是 0。
另有一個索引數組 indices，indices[i] = [ri, ci] 中的 ri 和 ci 分別表示指定的行和列（從 0 開始編號）。
你需要將每對 [ri, ci] 指定的行和列上的所有單元格的值加 1。
請你在執行完所有 indices 指定的增量操作後，返回矩陣中 「奇數值單元格」 的數目。
示例 1：
輸入：n = 2, m = 3, indices = [[0,1],[1,1]]
輸出：6
解釋：最開始的矩陣是 [[0,0,0],[0,0,0]]。
第一次增量操作後得到 [[1,2,1],[0,1,0]]。
最後的矩陣是 [[1,3,1],[1,3,1]]，裏面有 6 個奇數。
示例 2：
輸入：n = 2, m = 2, indices = [[1,1],[0,0]]
輸出：0
解釋：最後的矩陣是 [[2,2],[2,2]]，裏面沒有奇數。
提示：
1 <= n <= 50
1 <= m <= 50
1 <= indices.length <= 100
0 <= indices[i][0] < n
0 <= indices[i][1] < m
這個題挺沒意思的。就不說了。
public int oddCells(int n, int m, int[][] indices) {
int[][] arr = new int[n][m];
for (int i = 0; i < indices.length; i++) {
for (int j = 0; j < m; j++) {
arr[indices[i][0]][j] += 1;
}
for (int j = 0; j < n; j++) {
arr[j][indices[i][1]] += 1;
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] % 2 == 1) {
sum++;
}
}
}
return sum;
}
5256. 重構 2 行二進制矩陣
5256. 重構 2 行二進制矩陣 顯示英文描述
用戶通過次數691
用戶嘗試次數812
通過次數700
提交次數2213
題目難度Medium
給你一個 2 行 n 列的二進制數組：
矩陣是一個二進制矩陣，這意味着矩陣中的每個元素不是 0 就是 1。
第 0 行的元素之和爲 upper。
第 1 行的元素之和爲 lower。
第 i 列（從 0 開始編號）的元素之和爲 colsum[i]，colsum 是一個長度爲 n 的整數數組。
你需要利用 upper，lower 和 colsum 來重構這個矩陣，並以二維整數數組的形式返回它。
如果有多個不同的答案，那麼任意一個都可以通過本題。
如果不存在符合要求的答案，就請返回一個空的二維數組。
示例 1：
輸入：upper = 2, lower = 1, colsum = [1,1,1]
輸出：[[1,1,0],[0,0,1]]
解釋：[[1,0,1],[0,1,0]] 和 [[0,1,1],[1,0,0]] 也是正確答案。
示例 2：
輸入：upper = 2, lower = 3, colsum = [2,2,1,1]
輸出：[]
示例 3：
輸入：upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]
輸出：[[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]
提示：
1 <= colsum.length <= 10^5
0 <= upper, lower <= colsum.length
0 <= colsum[i] <= 2
這個題乍一看，給我的第一直覺就是回溯。
結果。。。
先看一下回溯的代碼吧
private int nowUpper = 0;
private int nowLower = 0;
private boolean isFind = false;
private List<Integer> temListUpper = new ArrayList<>();
private List<Integer> temListLower = new ArrayList<>();
public List<List<Integer>> reconstructMatrix(int upper, int lower, int[] colsum) {
List<List<Integer>> lists = new ArrayList<>();
backtrack(0, lists, upper, lower, colsum);
return lists;
}
private void backtrack(int n, List<List<Integer>> lists, int upper, int lower, int[] colsum) {
if (n == colsum.length) {
if (upper == nowUpper && lower == nowLower) {
lists.add(new ArrayList<>(temListUpper));
lists.add(new ArrayList<>(temListLower));
isFind = true;
}
return;
}
if (isFind || (nowLower > lower && nowUpper > upper)) {
return;
}
switch (colsum[n]) {
case 0:
temListLower.add(0);
temListUpper.add(0);
backtrack(n + 1, lists, upper, lower, colsum);
temListLower.remove(temListLower.size() - 1);
temListUpper.remove(temListUpper.size() - 1);
break;
case 1:
for (int i = 0; i < 2; i++) {
if (i == 0) {
temListLower.add(0);
temListUpper.add(1);
nowUpper += 1;
backtrack(n + 1, lists, upper, lower, colsum);
temListLower.remove(temListLower.size() - 1);
temListUpper.remove(temListUpper.size() - 1);
nowUpper -= 1;
} else {
temListLower.add(1);
temListUpper.add(0);
nowLower += 1;
backtrack(n + 1, lists, upper, lower, colsum);
temListLower.remove(temListLower.size() - 1);
temListUpper.remove(temListUpper.size() - 1);
nowLower -= 1;
}
}
break;
case 2:
nowUpper += 1;
nowLower += 1;
temListLower.add(1);
temListUpper.add(1);
backtrack(n + 1, lists, upper, lower, colsum);
temListLower.remove(temListLower.size() - 1);
temListUpper.remove(temListUpper.size() - 1);
nowUpper -= 1;
nowLower -= 1;
break;
}
}
- 是1的話分爲兩種情況
- 是0和2的話就是一種情況
- 借用兩個變量nowUpper 和 nowLower來記錄當前的值
一看這個數據量
1 <= colsum.length <= 10^5
哈哈，穩穩的超時。
最後想想，這個題其實並不是什麼算法題，兩遍循環就搞定了。
public List<List<Integer>> reconstructMatrix2(int upper, int lower, int[] colsum) {
List<List<Integer>> lists = new ArrayList<>(3);
int[][] arr = new int[2][colsum.length];
for (int i = 0; i < colsum.length; i++) {
if (colsum[i] == 2) {
arr[0][i] = 1;
arr[1][i] = 1;
upper--;
lower--;
if (upper < 0 || lower < 0) {
return lists;
}
}
}
for (int i = 0; i < colsum.length; i++) {
if (colsum[i] == 1) {
if (upper > 0) {
arr[0][i] = 1;
upper--;
} else if (lower > 0) {
arr[1][i] = 1;
lower--;
} else {
return lists;
}
}
}
if (lower != 0 || upper != 0) {
return lists;
}
List<Integer> list1 = new ArrayList<>(colsum.length + 1);
List<Integer> list2 = new ArrayList<>(colsum.length + 1);
for (int i = 0; i < arr[0].length; i++) {
list1.add(arr[0][i]);
list2.add(arr[1][i]);
}
lists.add(list1);
lists.add(list2);
return lists;
}
- 第一次把2的全部填完。這時切記要檢查upper 和 lower
- 第二次填的就是1的，如果upper 還可以填，就先填upper的，否則就填lower的。最後都不能填的話，那就意味着，還有1沒放入，但是upper lower的值不允許放，這種情況下，直接就無解了
- 最後轉換成list即可
5257. 統計封閉島嶼的數目
5257. 統計封閉島嶼的數目 顯示英文描述
用戶通過次數436
用戶嘗試次數513
通過次數440
提交次數793
題目難度Medium
有一個二維矩陣 grid ，每個位置要麼是陸地（記號爲 0 ）要麼是水域（記號爲 1 ）。
我們從一塊陸地出發，每次可以往上下左右 4 個方向相鄰區域走，能走到的所有陸地區域，我們將其稱爲一座「島嶼」。
如果一座島嶼 完全 由水域包圍，即陸地邊緣上下左右所有相鄰區域都是水域，那麼我們將其稱爲 「封閉島嶼」。
請返回封閉島嶼的數目。
示例 1：
輸入：grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
輸出：2
解釋：
灰色區域的島嶼是封閉島嶼，因爲這座島嶼完全被水域包圍（即被 1 區域包圍）。
示例 2：
輸入：grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
輸出：1
示例 3：
輸入：grid = [[1,1,1,1,1,1,1],
[1,0,0,0,0,0,1],
[1,0,1,1,1,0,1],
[1,0,1,0,1,0,1],
[1,0,1,1,1,0,1],
[1,0,0,0,0,0,1],
[1,1,1,1,1,1,1]]
輸出：2
提示：
1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1
這個題應該用深搜也可以吧，但是不太好寫應該。
我用廣搜做的。
boolean[][] isVisit;
boolean isHave = true;
public int closedIsland(int[][] grid) {
isVisit = new boolean[grid.length][grid[0].length];
int count = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[i].length; j++) {
if (grid[i][j] == 0 && !isVisit[i][j]) {
BFS(i, j, grid);
if (isHave) {
count++;
}
}
isHave = true;
}
}
return count;
}
private void BFS(int i, int j, int[][] grid) {
Queue<List<Integer>> queue = new LinkedList<>();
queue.add(new ArrayList<>(Arrays.asList(i, j)));
while (!queue.isEmpty()) {
int size = queue.size();
for (int k = 0; k < size; k++) {
List<Integer> list = queue.poll();
int i1 = list.get(0);
int j1 = list.get(1);
isVisit[i1][j1] = true;
if (i1 == 0 || i1 == grid.length - 1 || j1 == 0 || j1 == grid[0].length - 1) {
isHave = false;
}
if (i1 - 1 >= 0 && grid[i1 - 1][j1] == 0 && !isVisit[i1 - 1][j1]) {
queue.add(new ArrayList<>(Arrays.asList(i1 - 1, j1)));
}
if (i1 + 1 < grid.length && grid[i1 + 1][j1] == 0 && !isVisit[i1 + 1][j1]) {
queue.add(new ArrayList<>(Arrays.asList(i1 + 1, j1)));
}
if (j1 - 1 >= 0 && grid[i1][j1 - 1] == 0 && !isVisit[i1][j1 - 1]) {
queue.add(new ArrayList<>(Arrays.asList(i1, j1 - 1)));
}
if (j1 + 1 < grid[0].length && grid[i1][j1 + 1] == 0 && !isVisit[i1][j1 + 1]) {
queue.add(new ArrayList<>(Arrays.asList(i1, j1 + 1)));
}
}
}
}
- 我的理解是，不封閉，那就意味着，有元素在這個矩陣的邊界，事實證明確實如此。所以當我們發現一個區域包含邊界點時，那他就是不封閉的。
- 由是0的點開始廣搜，我們可以發現不管是封閉還是不封閉，當開始搜的話，都可以把這一片封閉或者不封閉的區域訪問完，所以啊，我們都每次訪問的點設置標記。以後對這個點進行BFS的時候，就可以不搜索了。
- 思路就是這麼簡單，代碼在上面。
5258. 得分最高的單詞集合
5258. 得分最高的單詞集合 顯示英文描述
用戶通過次數222
用戶嘗試次數247
通過次數227
提交次數385
題目難度Hard
你將會得到一份單詞表 words，一個字母表 letters （可能會有重複字母），以及每個字母對應的得分情況表 score。
請你幫忙計算玩家在單詞拼寫遊戲中所能獲得的「最高得分」：能夠由 letters 裏的字母拼寫出的 任意 屬於 words 單詞子集中，分數最高的單詞集合的得分。
單詞拼寫遊戲的規則概述如下：
玩家需要用字母表 letters 裏的字母來拼寫單詞表 words 中的單詞。
可以只使用字母表 letters 中的部分字母，但是每個字母最多被使用一次。
單詞表 words 中每個單詞只能計分（使用）一次。
根據字母得分情況表score，字母 'a', 'b', 'c', ... , 'z' 對應的得分分別爲 score[0], score[1], ..., score[25]。
本場遊戲的「得分」是指：玩家所拼寫出的單詞集合裏包含的所有字母的得分之和。
示例 1：
輸入：words = ["dog","cat","dad","good"], letters = ["a","a","c","d","d","d","g","o","o"], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]
輸出：23
解釋：
字母得分爲 a=1, c=9, d=5, g=3, o=2
使用給定的字母表 letters，我們可以拼寫單詞 "dad" (5+1+5)和 "good" (3+2+2+5)，得分爲 23 。
而單詞 "dad" 和 "dog" 只能得到 21 分。
示例 2：
輸入：words = ["xxxz","ax","bx","cx"], letters = ["z","a","b","c","x","x","x"], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,10]
輸出：27
解釋：
字母得分爲 a=4, b=4, c=4, x=5, z=10
使用給定的字母表 letters，我們可以組成單詞 "ax" (4+5)， "bx" (4+5) 和 "cx" (4+5) ，總得分爲 27 。
單詞 "xxxz" 的得分僅爲 25 。
示例 3：
輸入：words = ["leetcode"], letters = ["l","e","t","c","o","d"], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]
輸出：0
解釋：
字母 "e" 在字母表 letters 中只出現了一次，所以無法組成單詞表 words 中的單詞。
提示：
1 <= words.length <= 14
1 <= words[i].length <= 15
1 <= letters.length <= 100
letters[i].length == 1
score.length == 26
0 <= score[i] <= 10
words[i] 和 letters[i] 只包含小寫的英文字母。
這個題啊，乍一看，好像挺難，其實也就一般，我才做了1個小時·········。
private int[] hash;
private int sco = 0;
private int max = 0;
private HashMap<String, Integer> map;
public int maxScoreWords(String[] words, char[] letters, int[] score) {
hash = new int[150];
map = new HashMap<>();
for (char letter : letters) {
hash[letter] += 1;
}
for (int i = 0; i < words.length; i++) {
int s = 0;
for (int j = 0; j < words[i].length(); j++) {
s += score[words[i].charAt(j) - 'a'];
}
map.put(words[i], s);
}
backtrack(0, words, letters, score);
return max;
}
private void backtrack(int n, String[] words, char[] letters, int[] score) {
if (n >= words.length) {
max = Math.max(sco, max);
return;
}
for (int i = 0; i < 2; i++) {
if (i == 0) {
boolean ok = true;
for (int j = 0; j < words[n].length(); j++) {
hash[words[n].charAt(j)] -= 1;
if (hash[words[n].charAt(j)] < 0) {
ok = false;
}
}
if (ok) {
sco += map.get(words[n]);
backtrack(n + 1, words, letters, score);
sco -= map.get(words[n]);
}
for (int j = 0; j < words[n].length(); j++) {
hash[words[n].charAt(j)] += 1;
}
} else {
backtrack(n + 1, words, letters, score);
}
}
}
注意這個數據量啊
1 <= words.length <= 14
直接回溯就完事了，當然還是要做一點點優化的。
解題步驟如下：
- 建一個hash數組，記錄字母的個數
- 建一個map，存word的得分
- 然後，回溯
- 對於一個單詞，他就兩種可能，要麼有它，要麼沒有
- 第一種：有他的話，我們需要在hash數組裏面，減去單詞裏面每個字母出現的個數，然後判斷一下，可用的字母是不是用完了，沒用完就繼續走下一個單詞。用完了那就把剛纔減的再加回來。需要注意的是，當遞歸調用完下一個單詞回來時，也要把減過的單詞再加上。
- 第二種，沒有他，那就什麼事也沒有，直接遞歸調用下一個單詞
- 當調用到最後一個時，通過max判斷一下。
- 最後返回。