1、奇數值單元格的數目
給你一個 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
思路：讀清題意、直接模擬即可，簽到題。
參考代碼：
class Solution {
public int oddCells(int n, int m, int[][] indices)
{
int ans=0;
int[][] arr=new int[n][m];
for(int i=0;i<indices.length;i++)
{
for(int ii=0;ii<n;ii++)
arr[ii][indices[i][1]]++;
for(int jj=0;jj<m;jj++)
arr[indices[i][0]][jj]++;
}
for(int[] ins:arr)
{
for(int in:ins)
{
System.out.print(in+" ");
if(in%2==1)
ans++;
}
}
return ans;
}
}
2、重構 2 行二進制矩陣
給你一個 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
思路：貪心，首先，colsum 值爲2的比如上下都有1，upper和lower都自減一，然後循環遍歷colsum值爲1的位置，如果upper大於零，uper–，否則lower–。最後判斷一下如果upper和lower都爲0，返回該矩陣，否則不存在合格的矩陣返回空。
參考代碼：
class Solution {
public List<List<Integer>> reconstructMatrix(int upper, int lower, int[] colsum)
{
int[][] arr=new int[2][colsum.length];
int sum=0;
for(int i=0;i<colsum.length;i++)
sum+=colsum[i];
if(sum!=upper+lower)
return new ArrayList<List<Integer>>();
for(int i=0;i<colsum.length;i++)
{
if(colsum[i]==2)
{
upper--;
lower--;
arr[0][i]=1;
arr[1][i]=1;
}
}
for(int j=0;j<colsum.length;j++)
{
if(colsum[j]==1)
{
if(upper>0)
{
upper--;
arr[0][j]=1;
}
else
{
lower--;
arr[1][j]=1;
}
}
}
if(upper<0||lower<0)
return new ArrayList<List<Integer>>();
List<List<Integer>> ans=new ArrayList<List<Integer>>();
for(int[] ins:arr)
{
List<Integer> list=new ArrayList<Integer>();
for(int in:ins)
{
list.add(in);
System.out.print(in+" ");
}
System.out.println();
ans.add(list);
}
return ans;
}
}
3、統計封閉島嶼的數目
有一個二維矩陣 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
提示：
1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1
思路：直接dfs搜索，但有了一個封閉島嶼的限制條件。把島嶼的部分標記一下，直到最後一步，再枚舉最後一步四個方向的下一步，如果要是出界了，說明這片島嶼不是封閉島嶼。
參考代碼：
class Solution {
int ans=0;
int mmp=0;
public int closedIsland(int[][] grid)
{
int[][] book=new int[grid.length][grid[0].length];
for(int i=0;i<grid.length;i++)
{
for(int j=0;j<grid[0].length;j++)
{
if(grid[i][j]==0)
{
mmp=0;
dfs(grid,i,j);
System.out.println(i+","+j+" "+mmp);
if(mmp==0)
ans++;
}
}
}
return ans;
}
private void dfs(int[][] grid,int x,int y)
{
int[][] next= {{0,1},{1,0},{0,-1},{-1,0}};
for(int i=0;i<next.length;i++)
{
int xx=x+next[i][0];
int yy=y+next[i][1];
if(check(grid,xx,yy)&&grid[xx][yy]==0)
{
grid[xx][yy]=2;
dfs(grid, xx, yy);
}
}
int flag=0;
for(int i=0;i<next.length;i++)
{
int xx=x+next[i][0];
int yy=y+next[i][1];
if(!check(grid, xx, yy))
flag=1;
}
if(flag==1)
mmp=1;
}
private boolean check(int[][] grid, int xx, int yy)
{
if(xx>=0&&xx<grid.length&&yy>=0&&yy<grid[0].length)
return true;
return false;
}
}
4、得分最高的單詞集合
你將會得到一份單詞表 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] 只包含小寫的英文字母。
思路：由於給出的數據範圍很小，可以直接暴力枚舉，每個單詞都有使用和不使用兩種情況，枚舉出它們的所有情況，然後判斷這些情況是否符合條件。
參考代碼：
class Solution {
int ans=0;
public int maxScoreWords(String[] words, char[] letters, int[] score)
{
Map<Character,Integer> map=new HashMap<Character,Integer>();
for(char ch:letters)
{
if(map.containsKey(ch))
{
int val = map.get(ch);
map.put(ch, ++val);
}
else
map.put(ch, 1);
}
int[] book=new int[words.length];
dfs(words,score,map,book,0);
return ans;
}
private void dfs(String[] words, int[] score,Map<Character,Integer> map,int[] book, int k)
{
if(k==book.length)
{
int t = getS(words,score,map,book);
ans=Math.max(t, ans);
return ;
}
book[k]=1;
dfs(words, score,map, book, k+1);
book[k]=0;
dfs(words, score,map, book, k+1);
}
private int getS(String[] words, int[] score, Map<Character, Integer> map, int[] book)
{
int res=0;
Map<Character,Integer> t=new HashMap<Character,Integer>();
for(int i=0;i<book.length;i++)
{
if(book[i]==1)
{
for(int j=0;j<words[i].length();j++)
{
char ch=words[i].charAt(j);
if(t.containsKey(ch))
{
int val = t.get(ch);
t.put(ch, ++val);
}
else
t.put(ch, 1);
}
}
}
Set<Character> keys = t.keySet();
for(char key:keys)
{
if(map.containsKey(key)&&map.get(key)>=t.get(key))
{}
else
return 0;
}
for(char key:keys)
res+=t.get(key)*score[key-'a'];
return res;
}
}