《剑指Offer》C++实现-Week5

57. 数字序列中某一位的数字

数字以0123456789101112131415…的格式序列化到一个字符序列中。

在这个序列中，第5位（从0开始计数）是5，第13位是1，第19位是4，等等。

请写一个函数求任意位对应的数字。

样例
输入：13

输出：1

class Solution {
public:
    /*
    1.确定是几位数 n - 10 - 90 * 2 - 900 * 3 -....
    2.确定是几位数的第几个数 1000 + 256 - 1 = 1255
    3.属于那个数的第几位 
    */
    int digitAtIndex(int n) {
        n ++, n --;
        long long i = 1, s = 9, base = 1;
        while(n > i * s)
        {
            n -= i * s;
            i ++;
            s *= 10;
            base *= 10;
        }
        
        int number = base + (n + i - 1) / i - 1;//确定是几位数的第几个数
        int r = n % i ? n % i : i;
        
        for(int j = 0; j < i - r; j ++) number /= 10;//属于那个数的第几位
        
        return number % 10;
    }
};

58. 把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

例如输入数组[3, 32, 321]，则打印出这3个数字能排成的最小数字321323。

样例
输入：[3, 32, 321]

输出：321323
注意：输出数字的格式为字符串。

class Solution {
public:

    static bool cmp(int a, int b)
    {
        auto as = to_string(a), bs = to_string(b);
        return as + bs < bs + as;
    }

    string printMinNumber(vector<int>& nums) {
        sort(nums.begin(), nums.end(), cmp);
        string res;
        for(auto x : nums) res += to_string(x);
        return res;
    }
};

59. 把数字翻译成字符串

给定一个数字，我们按照如下规则把它翻译为字符串：

0翻译成”a”，1翻译成”b”，……，11翻译成”l”，……，25翻译成”z”。

一个数字可能有多个翻译。例如12258有5种不同的翻译，它们分别是”bccfi”、”bwfi”、”bczi”、”mcfi”和”mzi”。

请编程实现一个函数用来计算一个数字有多少种不同的翻译方法。

样例
输入：“12258”

输出：5

class Solution {
public:
    int getTranslationCount(string s) {
        int n = s.size();
        vector<int> f(n + 1);
        f[0] = 1;
        for(int i = 1; i <= n; i ++)
        {
            f[i] = f[i - 1];
            int t = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
            if(t >= 10 && t <=25) f[i] += f[i - 2];
        }
        return f[n];
    }
};

60. 礼物的最大价值

在一个m×n的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于0）。

你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格直到到达棋盘的右下角。

给定一个棋盘及其上面的礼物，请计算你最多能拿到多少价值的礼物？

注意：

m,n>0
样例：

输入：

[
  [2,3,1],
  [1,7,1],
  [4,6,1]
]

输出：19

解释：沿着路径 2→3→7→6→1 可以得到拿到最大价值礼物。

class Solution {
public:
    int getMaxValue(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<int>> f(n + 1, vector<int>(m + 1));
        for(int i = 1; i <= n; i ++)
            for(int j = 1; j <= m; j++)
                f[i][j] = max(f[i - 1][j], f[i][j - 1]) + grid[i - 1][j - 1];
        return f[n][m];        
    }
};

61. 最长不含重复字符的子字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

假设字符串中只包含从’a’到’z’的字符。

样例
输入：“abcabc”

输出：3

class Solution {
public:
    int longestSubstringWithoutDuplication(string s) {
        unordered_map<char, int> count;
        int res = 0;
        for(int i = 0, j = 0; j < s.size(); j ++)
        {
            if(++ count[s[j]] > 1) 
            {
                
                while(count[s[i]] == 1) count[s[i ++]] --;
                count[s[i ++]] --;
            }
            res = max(res, j - i + 1);
        }
        return res;
    }
};

62. 丑数

我们把只包含质因子2、3和5的数称作丑数（Ugly Number）。

例如6、8都是丑数，但14不是，因为它包含质因子7。

求第n个丑数的值。

样例
输入：5

输出：5
注意：习惯上我们把1当做第一个丑数。

class Solution {
public:
    int getUglyNumber(int n) {
        vector<int> q(1, 1);
        int i = 0, j = 0, k = 0;
        while(-- n)
        {
            int t = min(q[i] * 2, min(q[j] * 3, q[k] * 5));
            q.push_back(t);
            if(q[i] * 2 == t) i ++;
            if(q[j] * 3 == t) j ++;
            if(q[k] * 5 == t) k ++;
        }
        return q.back();
    }
};

63. 字符串中第一个只出现一次的字符

在字符串中找出第一个只出现一次的字符。

如输入"abaccdeff"，则输出b。

如果字符串中不存在只出现一次的字符，返回#字符。

样例：
输入：“abaccdeff”

输出：‘b’

class Solution {
public:
    char firstNotRepeatingChar(string s) {
        unordered_map<char, int> count;
        for(auto c : s) count[c] ++;
        char res = '#';
        for(auto c : s)
        {
            if(count[c] == 1)
            {
                res = c;
                break;
            }
        }
        return res;
    }
};

64. 字符流中第一个只出现一次的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。

例如，当从字符流中只读出前两个字符”go”时，第一个只出现一次的字符是’g’。

当从该字符流中读出前六个字符”google”时，第一个只出现一次的字符是’l’。

如果当前字符流没有存在出现一次的字符，返回#字符。

样例
输入：“google”

输出：“ggg#ll”

解释：每当字符流读入一个字符，就进行一次判断并输出当前的第一个只出现一次的字符。

class Solution{
public:

    unordered_map<char, int>count;
    queue<int> q;

    //Insert one char from stringstream
    void insert(char ch){
        if(++ count[ch] >1)
        {
            while(q.size() && count[q.front()] > 1) q.pop();
        }
        else q.push(ch);
    }
    //return the first appearence once char in current stringstream
    char firstAppearingOnce(){
        if(q.empty()) return '#';
        return q.front();
    }
};

65. 数组中的逆序对

在数组中的两个数字如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。

输入一个数组，求出这个数组中的逆序对的总数。

样例
输入：[1,2,3,4,5,6,0]

输出：6

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

class Solution {
public:

    int merage(vector<int> &nums, int l, int r)
    {
        if(l >= r) return 0;
        int mid = l + r >> 1;
        int res = merage(nums, l, mid) + merage(nums, mid + 1, r);
        int i = l, j = mid + 1;
        vector<int> temp;
        while(i <= mid && j <= r)
        {
            if(nums[i] <= nums[j]) temp.push_back(nums[i ++]);
            else 
            {
                temp.push_back(nums[j ++]);
                res += mid - i + 1;
            }
        }
        while(i <= mid) temp.push_back(nums[i ++]);
        while(j <= r) temp.push_back(nums[j ++]);
        i = l;
        for(auto x : temp) nums[i ++] = x;
        return res;
    }

    int inversePairs(vector<int>& nums) {
        return merage(nums, 0, nums.size() - 1);
    }
};

66. 两个链表的第一个公共结点

输入两个链表，找出它们的第一个公共结点。

当不存在公共节点时，返回空节点。

样例
给出两个链表如下所示：

A：        a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3

输出第一个公共节点c1

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {
        auto p = headA, q = headB;
        while(p != q)
        {
            if(p) p = p->next;
            else p = headB;
            if(q) q= q->next;
            else q = headA;
        }
        return q;
    }
};

67. 数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

例如输入排序数组[1, 2, 3, 3, 3, 3, 4, 5]和数字3，由于3在这个数组中出现了4次，因此输出4。

样例
输入：[1, 2, 3, 3, 3, 3, 4, 5] , 3

输出：4

class Solution {
public:
    int getNumberOfK(vector<int>& nums , int k) {
        int res = 0;
        for(auto x : nums)
        {
            if(x == k)
                res ++;
        }
        return res;
    }
};

class Solution {
public:
    int getNumberOfK(vector<int>& nums , int k) {
        if(nums.empty()) return 0;
        
        int l = 0, r = nums.size() - 1;
        while(l < r)
        {
            int mid = l + r >> 1;
            if(nums[mid] < k) l = mid + 1;
            else r = mid;
        }
        
        if(nums[l] != k) return 0;
        
        int left = l;
        
        l = 0, r = nums.size() - 1;
        while(l < r)
        {
            int mid = l + r + 1 >> 1;
            if(nums[mid] <= k) l = mid;
            else r = mid - 1;
        }
        return r - left + 1;
    }
};