914. 卡牌分组；999. 可以被一步捕获的棋子数；1143. 最长公共子序列

给定一副牌，每张牌上都写着一个整数。

此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：

    每组都有 X 张牌。
    组内所有的牌上都写着相同的整数。

仅当你可选的 X >= 2 时返回 true。

 

示例 1：

输入：[1,2,3,4,4,3,2,1]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[3,3]，[4,4]

示例 2：

输入：[1,1,1,2,2,2,3,3]
输出：false
解释：没有满足要求的分组。

示例 3：

输入：[1]
输出：false
解释：没有满足要求的分组。

示例 4：

输入：[1,1]
输出：true
解释：可行的分组是 [1,1]

示例 5：

输入：[1,1,2,2,2,2]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[2,2]

 

提示：

    1 <= deck.length <= 10000
    0 <= deck[i] < 10000

class Solution {
public:
    bool hasGroupsSizeX(vector& deck) {
        vectorcnt(10000,0);
        for(auto &i:deck)
            ++cnt[i];
        int res=0;
        for(int i=0;i<10000;++i)
            if(res)res=gcdSelf(res,cnt[i]);
                //res=gcd(res,cnt[i]);
            else res=cnt[i];
        return res>=2;
    }
    int gcdSelf(int a,int b){
        return a?gcdSelf(b%a,a):b;
        //return b?gcdSelf(b,a%b):a;
    }
};

在一个 8 x 8 的棋盘上，有一个白色的车（Rook），用字符 'R' 表示。棋盘上还可能存在空方块，白色的象（Bishop）以及黑色的卒（pawn），分别用字符 '.'，'B' 和 'p' 表示。不难看出，大写字符表示的是白棋，小写字符表示的是黑棋。

车按国际象棋中的规则移动。东，西，南，北四个基本方向任选其一，然后一直向选定的方向移动，直到满足下列四个条件之一：

    棋手选择主动停下来。
    棋子因到达棋盘的边缘而停下。
    棋子移动到某一方格来捕获位于该方格上敌方（黑色）的卒，停在该方格内。
    车不能进入/越过已经放有其他友方棋子（白色的象）的方格，停在友方棋子前。

你现在可以控制车移动一次，请你统计有多少敌方的卒处于你的捕获范围内（即，可以被一步捕获的棋子数）。

提示：

    board.length == board[i].length == 8
    board[i][j] 可以是 'R'，'.'，'B' 或 'p'
    只有一个格子上存在 board[i][j] == 'R'

class Solution {
public:
    int numRookCaptures(vector>& board) {
        int cnt=0;
        vectordx={1,0,-1,0},dy={0,1,0,-1};
        for(int i=0;i<8;++i)
            for(int j=0;j<8;++j)
                if(board[i][j]=='R'){
                    for(int k=0;k<4;++k)
                        for(int x=i+dx[k],y=j+dy[k];!(x<0||y<0||x==8||y==8||board[x][y]=='B');x+=dx[k],y+=dy[k])
                            if(board[x][y]=='p'){
                                ++cnt;
                                break;
                            }
                    return cnt;
                }                    
        return cnt;
    }
};

 

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

 

示例 1:

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace"，它的长度为 3。

示例 2:

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc"，它的长度为 3。

示例 3:

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0。

 

提示:

    1 <= text1.length <= 1000
    1 <= text2.length <= 1000
    输入的字符串只含有小写英文字符。

class Solution {    //二维动态规划
  public:
    int longestCommonSubsequence(string text1, string text2) {
        vector> dp(text1.size() + 1, vector (text2.size() + 1, 0));
        for (int i = 1; i <= text1.size(); ++i) {
            for (int j = 1;j <= text2.size(); ++j) {
                if (text1[i-1] == text2[j-1]) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
                }
            }
        }
        return dp[text1.size()][text2.size()];
    }
};

 

class Solution {    //一维动态规划
public:
    int longestCommonSubsequence (string text1, string text2) {
        vector dp(text2.size() + 1, 0);
        for (int i = 1; i <= text1.size(); ++i) {
            int left_up = dp[0];    //
            for (int j = 1;j <= text2.size(); ++j) {
                int tmp = dp[j];    //
                if (text1[i-1] == text2[j-1]) {
                    dp[j] = left_up + 1;
                } else {
                    dp[j] = max(dp[j-1], dp[j]);
                }
                left_up = tmp;      //
            }
        }
        return dp[text2.size()];
    }
};