leetcode解题思路分析（二十六）187 - 192题

187. 重复的DNA序列
     编写一个函数来查找 DNA 分子中所有出现超过一次的 10 个字母长的序列（子串）。

class Solution {
public:
    vector<string> findRepeatedDnaSequences(string s) 
    {
        //对应二进制00, 01, 10, 11.那么10个组合只要20位就够了。
        unordered_map<char, int> m{{'A', 0}, {'C', 1}, {'G', 2}, {'T', 3}};
        vector<string> res;
        bitset<1 << 20> s1, s2; //那么所有组合的值将在0到(1 << 20 - 1)之间
        int val = 0, mask = (1 << 20) - 1; //mask等于二进制的20个1
        //类似与滑动窗口先把前10个字母组合
        for (int i = 0; i < 10; ++i) val = (val << 2) | m[s[i]];
        s1.set(val); //置位
        for (int i = 10; i < s.size(); ++i)
        {
            val = ((val << 2) & mask) | m[s[i]]; //去掉左移的一个字符再加上一个新字符
            if (s2.test(val)) continue; //出现过两次跳过
            if (s1.test(val))
            {
                res.push_back(s.substr(i - 9, 10));
                s2.set(val);
            }
            else s1.set(val);
        }
        return res;
    }
};

188. 买卖股票的最佳时机4
     给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
     设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
     注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

本题采用动态规划求解，和前面几题的区别在于需要考虑k。如果K比较多支持每天都在买和卖，则直接累加，否则需要考虑哪天卖出最划算

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(!prices.size()) return 0;
        if(k >= prices.size()/2)
        {
            int maxsumval = 0;
            for(int i = 1; i < prices.size(); i++)
                if(prices[i] > prices[i - 1])
                    maxsumval += prices[i] - prices[i - 1];
            return maxsumval;
        }
        vector<int> dp(k + 1, 0);
        vector<int> v(k + 1, prices[0]);
        for(int i = 1; i < prices.size(); i++)
        {
            for(int t = 1; t <= k; t++)
            {
                v[t] = min(v[t], prices[i] - dp[t - 1]);
                dp[t] = max(dp[t], prices[i] - v[t]);  
            }
        } 
        return dp[k];
    }
};

189. 旋转数组
     给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

首先将所有元素反转。然后反转前 k 个元素，再反转后面 n-kn−k 个元素，就能得到想要的结果。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        reverse(nums.begin(), nums.end() - k % nums.size());
        reverse(nums.end() - k % nums.size(), nums.end());
        reverse(nums.begin(), nums.end());
    }
};

190. 颠倒二进制位
     颠倒给定的 32 位无符号整数的二进制位。

首先，我们将原来的 32 位分为 2 个 16 位的块。
然后我们将 16 位块分成 2 个 8 位的块。
然后我们继续将这些块分成更小的块，直到达到 1 位的块。
在上述每个步骤中，我们将中间结果合并为一个整数，作为下一步的输入。

class Solution {
public:
    uint32_t reverseBits(uint32_t n) {
        n = (n >> 16) | (n << 16);
        n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8);
        n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4);
        n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2);
        n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1);
        return n;
    }
};

191. 位1的个数
     编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数

最简单的方法就是逐位检查

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int ret = 0;
        while(n)        
        {
            if (n & 1) ret++;
            n >>= 1;
        }
        return ret;
    }
};

在二进制表示中，数字 nn 中最低位的 11 总是对应 n - 1n−1 中的 00 。因此，将 nn 和 n - 1n−1 与运算总是能把 nn 中最低位的 11 变成 00 ，并保持其他位不变。

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count = 0;

        while(n > 0)
        {
            n &= (n - 1);
            ++count;
        }

        return count;
    }
};

192. 统计词频
     写一个 bash 脚本以统计一个文本文件 words.txt 中每个单词出现的频率。

本题其实分两步，第一步是单次分割，第二步是将分割的单次进行统计。

单次分割可以使用awk或者cat 加xargs实现

awk '{for(i=1;i<=NF;i++){print $i}}' words.txt 

cat words.txt | xargs -n1

使用awk命令来完成这个任务的话很简单，在进行分割的过程中直接用一个关联数组直接保存每一个单词出现的次数

awk '{for(i=1;i<=NF;i++){asso_array[$i]++;}};END{for(w in asso_array){print w,asso_array[w];}}' words.txt

使用cat + xargs的话需要使用sort以及uniq实现

cat words.txt | xargs -n1 | sort | uniq -c

最终代码

awk '{for(i=1;i<=NF;i++){asso_array[$i]++;}};END{for(w in asso_array){print w,asso_array[w];}}' words.txt | sort -rn -k2

cat words.txt | xargs -n1 | sort | uniq -c | sort -rn | awk '{print $2,$1}'