948. 令牌放置

題解: 貪心演算法：tokens從小到大排序， 如果現在手裡面的能量還大於最小的token，我們就將其換成分數(這樣做怎麼都不會虧，因為我們可以用分數去換更大的)；否則如果我們手裡還有分數，我們就去換最大的token。

class Solution {
public:
    bool vis[1005][2];
    int bagOfTokensScore(vector<int>& tokens, int P) {
        sort(tokens.begin(), tokens.end());
        int i = 0,j= tokens.size()-1
 
,score = 0,ans=0 ;
        while(i<=j){
            if(P>=tokens[i]){
                score++; 
                P-=tokens[i++];
            }else if(score>=1){
                score--;
                P+=tokens[j--];
            }else break;
            ans = max(ans, score);
        }
        
 
return ans;
    }
};

740. 刪除與獲得點數

題解：動態規劃: 首先把每個點數出現的數量統計一下，第i個點出現的次數為count[i]，接下來就是經典的選與不選(相鄰的不能選，不相鄰的必選)的問題。dp[i] = min(dp[i-1] , dp[i-2]+i*count[i])。

class Solution {
public:
    int count[10005], dp[10005];
    int deleteAndEarn(vector<int>& nums) {
        for(int i=0;i<nums.size();i++) count[nums[i]]++;
        dp[
 
1] = count[1], dp[2] = max(count[2]*2, dp[1]); 
        for(int i=3;i<=10000;i++){
            dp[i] = max(dp[i-2] + i*count[i], dp[i-1]);
           // printf("%d %d\n",i, dp[i]);
        }
        return dp[10000];
    }
};

1367. 二叉樹中的列表

題解: 對樹做遍歷，若當前root->val == head->val 則單獨進行遞迴。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isok(ListNode* head, TreeNode* root){
        if(head==NULL) return true;
        if(root==NULL) return false;
        if(head->val == root->val){
            return isok(head->next, root->left) || isok(head->next, root->right);
        }
        return false;
    }
    bool isSubPath(ListNode* head, TreeNode* root) {
        if(root==NULL) return false;
        bool flag = false;
        if(root->val == head->val) flag = isok(head, root);
        bool ok1 = isSubPath(head, root->left);
        bool ok2 = isSubPath(head, root->right);
        return flag || ok1 || ok2;
    }
};

1343. 大小為 K 且平均值大於等於閾值的子陣列數目

題解: 求出字首和，查詢即可。

class Solution {
public:
    
    int numOfSubarrays(vector<int>& arr, int k, int threshold) {
        vector<int> sum(arr.size());
        sum[0] = arr[0];
        for(int i=1;i<arr.size();i++){
            sum[i] = sum[i-1] + arr[i];
        }
        int ans = 0;
        if(sum[k-1]>=threshold*k) ans++;
        for(int i=k;i<arr.size();i++){
            int l = i-k, r = i;
            if(sum[r]-sum[l] >= threshold*k) ans++;
        }
        return ans;
    }
};

97. 交錯字串

題解: 動態規劃，很好的一道題，可以轉化為經典路徑搜尋，把第一個字串當成列，第二個字串當成行，每次都只能朝右(第二個字串)或者朝下(第一個字串)，問能夠找到一條從左上到右下的路徑。

class Solution {
public:
    int dp[2005][2005];
    bool isInterleave(string s1, string s2, string s3) {
        int n = s1.size(), m = s2.size();// s1 負責列方向， s2 負責行方向
        if(n+m!=s3.size()) return false;
        dp[0][0] = 1;
        for(int i=1;i<=n && s1[i-1] == s3[i-1];i++) dp[i][0] = true; 
        for(int i=1;i<=m && s2[i-1] == s3[i-1];i++) dp[0][i] = true;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                dp[i][j] = (dp[i-1][j] && s1[i-1] == s3[i+j-1]) || 
                            (dp[i][j-1] && s2[j-1] == s3[i+j-1]);
            }
        }
        return dp[n][m];
    }
};