LeetCode (G)

Gas Station

  Total Accepted: 3278  Total Submissions: 14438 My Submissions

There are N gas stations along a circular route, where the amount of gas at station i is gas[i].

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.

Return the starting gas station's index if you can travel around the circuit once, otherwise return -1.

Note:
The solution is guaranteed to be unique.

class Solution {
public:
        int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
                const int n = gas.size();
                int ans = 0, tmp = 0, mingas = INT_MAX;
                for (int i = 0; i < n; ++i) {
                        tmp += (gas[i] - cost[i]);
                        if (tmp < mingas) {
                                mingas = tmp;
                                ans = i + 1;
                        }
                }
                if (tmp < 0)
                        return -1;
                else
                        return ans % n;
        }
};

Generate Parentheses

  Total Accepted: 2484  Total Submissions: 8350 My Submissions

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

"((()))", "(()())", "(())()", "()(())", "()()()"

class Solution {
        vector<string> res;
        void genStr(const int t, const int k, string &str, const int n) {
                if (k + t == 2 * n) {
                        for (int i = 1; i <= k; ++i) str[2 * n - i] = ')';
                        res.push_back(str);
                        return;
                }
                if (k == 0) {
                        str[t] = '(';
                        genStr(t + 1, 1, str, n);
                }
                else {
                        str[t] = '(';
                        genStr(t + 1, k + 1, str, n);
                        str[t] = ')';
                        genStr(t + 1, k - 1, str, n);
                }
        }
public:
        vector<string> generateParenthesis(int n) {
                res.clear();
                string str(2 * n, '\0');
                genStr(0, 0, str, n);
                return res;
        }
};

Gray Code

  Total Accepted: 2004  Total Submissions: 6553 My Submissions

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

For example, given n = 2, return [0,1,3,2]. Its gray code sequence is:

00 - 0
01 - 1
11 - 3
10 - 2

Note:
For a given n, a gray code sequence is not uniquely defined.

For example, [0,2,3,1] is also a valid gray code sequence according to the above definition.

For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.

class Solution {
public:
        vector<int> grayCode(int n) {
                vector<int> res;
                res.push_back(0);
                if (n <= 0) return res;
                res.push_back(1);
                for (int w = 2; w <= n; ++w) {
                        int d = 1 << (w - 1), k = d - 1;
                        while (k >= 0)
                                res.push_back(res[k--] + d);
                }
                return res;
        }
};