leetcode 108

929. Unique Email Addresses
     用set点忽略，+后面忽略，@之后保存

class Solution {
public:
    int numUniqueEmails(vector<string>& emails) {
        set<string> res;
        for(int i=0;i<emails.size();i++){
            string tmp ="";
            bool flag = 0;
            int j;
            for(j=0;j<emails[i].size();j++){
                if(emails[i][j] == '@') break;
                else if(emails[i][j] == '.' || flag){
                }
                else if(emails[i][j] == '+'){
                    flag = 1;
                }
                else{
                    tmp = tmp+ emails[i][j];
                }  
            }
            tmp = tmp + emails[i].substr(j); 
            res.insert(tmp);
        }
       return res.size(); 
    }
};

930. Binary Subarrays With Sum
     双指针，第一个指针始终指向（和为S）第一个0，第二个始终指向（和为s+1）第一个1。

public int numSubarraysWithSum(int[] A, int S) {
        int i = 0, j = 0;
        int sum = 0, res = 0;
        for(; i < A.length; i++) {
            sum += A[i];
            if(sum == S) {
                int temp = 1;
                for(int k = j; k < i; k++) {
                    if(A[k] == 0) temp++;
                    else break;
                }
                res += temp;
            }
            while(j < i && sum > S) {
                sum -= A[j++];
                if(sum == S) {
                    sum -= A[i--];
                }
            }
        }
        return res;
    }

记录下我自己的办法。。

class Solution {
public:
    int numSubarraysWithSum(vector<int>& A, int S) {
        int sum = accumulate(A.begin(),A.end(),0);
        if(sum <S) return 0;
        if(!sum){
            return A.size()* (A.size()+1)/2;
        }
        vector<int> cntzero;
        int front = -1;
        for(int i=0;i<A.size();i++){
            if(A[i]==1){
                cntzero.push_back(i-front-1);
                front = i;
            }
        }
        cntzero.push_back(A.size()-front-1);
        int res = 0;
        for(int i=0;i<cntzero.size()-S;i++){
            if(S == 0){
                res = res + cntzero[i]* (cntzero[i]+1)/2;
            }else{
               res = res + (cntzero[i]+1)*(cntzero[i+S]+1); 
            }
            
        }
        return res;
    }
};

相似题目 560. Subarray Sum Equals K
prefix sum - k, 因为求和是固定的，因此j+1~I的求和可以转化为0～j的求和。

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int sum=0;
        int res =0;
        map<int,int> mm={{0,1}};
        for(int i=0;i<nums.size();i++){
            sum += nums[i];
            res = res + mm[sum -k];
            ++mm[sum];
        }
        return res;
    }
};

以上代码可以直接用在这道题930。
贴上复杂一点的n^2

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int res = 0, n = nums.size();
        vector<int> sums = nums;
        for (int i = 1; i < n; ++i) {
            sums[i] = sums[i - 1] + nums[i];
        }
        for (int i = 0; i < n; ++i) {
            if (sums[i] == k) ++res;
            for (int j = i - 1; j >= 0; --j) {
                if (sums[i] - sums[j] == k) ++res;
            }
        }
        return res;
    }
};

931. Minimum Falling Path Sum

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& A) {
        vector<vector<int>> dp(A.size(),vector<int>(A[0].size(),0));
        for(int i=0;i<A[0].size();i++){
            dp[A.size()-1][i] = A[A.size()-1][i];
        }
        for(int i=A.size()-2;i>=0;i--){
            for(int j=0;j<A[0].size();j++){
                if(j==0)dp[i][j] = A[i][j] + min(dp[i+1][j],dp[i+1][j+1]);
                else if(j==A[0].size()-1) dp[i][j] = A[i][j] + min(dp[i+1][j-1],dp[i+1][j]);
                else dp[i][j] = A[i][j] + min(min(dp[i+1][j-1],dp[i+1][j]), dp[i+1][j+1]);
            }
        }
        int res = INT_MAX;
        for(int i=0;i<A[0].size();i++){
            res = min(res,dp[0][i]);
        }
        return res;
    }
};

932. Beautiful Array

class Solution {
public:
    vector<int> beautifulArray(int N) {
        vector<int> res;
        if(N==1){
            res.push_back(1);
            return res;
        } 
        else{
            vector<int> vl= beautifulArray((N+1)/2);
            for(auto i:vl){
                res.push_back(2*i-1);
            }
            vector<int> vr= beautifulArray(N/2);
            for(auto j:vr){
                res.push_back(2*j);
            }
        }
        return res;
    }
};

找到一种方法组合数据，A[k] 必须为偶数，因此左边奇数，右边偶数，则和必为奇数满足条件。再使得左右两部分分别满足条件。迭代。
2[(N+1)/2]-1 || 2(N/2)