去掉 std::

Author: soulmachine

C++/LeetCodet题解(C++版).pdf

@@ -41,7 +41,7 @@ \subsubsection{代码}
     vector<vector<int> > subsets(vector<int> &S) {
         vector<vector<int> > result;
         vector<int> cur;
-        std::sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
+        sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
 
         subsets(S, cur, 0, result);
         return result;
@@ -78,7 +78,7 @@ \subsubsection{代码}
     vector<vector<int> > subsets(vector<int> &S) {
         vector<vector<int> > result;
         vector<bool> selected(S.size(), false);
-        std::sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
+        sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
 
         subsets(S, selected, 0, result);
         return result;
@@ -121,7 +121,7 @@ \subsubsection{代码}
 public:
     vector<vector<int> > subsets(vector<int> &S) {
         vector<vector<int> > result;
-        std::sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
+        sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
         const size_t n = S.size();
         vector<int> v;
 
@@ -181,31 +181,31 @@ \subsubsection{代码}
 public:
     vector<vector<int> > subsetsWithDup(vector<int> &S) {
         vector<vector<int> > result;
-        std::sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
+        sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
 
         unordered_map<int, int> count_map; // 记录每个元素的出现次数
-        std::for_each(S.begin(), S.end(), [&count_map](int e) {
+        for_each(S.begin(), S.end(), [&count_map](int e) {
             if (count_map.find(e) != count_map.end())
                 count_map[e]++;
             else
                 count_map[e] = 1;
         });
 
         // 将map里的pair拷贝到一个vector里
-        std::vector<pair<int, int> > elems;
-        std::for_each(count_map.begin(), count_map.end(),
+        vector<pair<int, int> > elems;
+        for_each(count_map.begin(), count_map.end(),
                 [&elems](const pair<int, int> &e) {
                     elems.push_back(e);
                 });
-        std::sort(elems.begin(), elems.end());
-        std::vector<int> path; // 中间结果
+        sort(elems.begin(), elems.end());
+        vector<int> path; // 中间结果
 
         subsets(elems, 0, path, result);
         return result;
     }
 
 private:
-    static void subsets(const std::vector<pair<int, int> > &elems,
+    static void subsets(const vector<pair<int, int> > &elems,
             size_t step, vector<int> &path, vector<vector<int> > &result) {
         if (step == elems.size()) {
             result.push_back(path);
@@ -232,15 +232,15 @@ \subsubsection{代码}
 public:
     vector<vector<int> > subsetsWithDup(vector<int> &S) {
         vector<vector<int> > result;
-        std::sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
-        std::vector<int> count(S.back() - S.front() + 1, 0);
+        sort(S.begin(), S.end()); // 本题对顺序有要求，需要排序
+        vector<int> count(S.back() - S.front() + 1, 0);
         // 计算所有元素的个数
         for(auto i = S.begin(); i != S.end(); i++) {
             count[*i - S[0]]++;
         }
 
         // 每个元素选择了多少个
-        std::vector<int> selected(S.back() - S.front() + 1, -1);
+        vector<int> selected(S.back() - S.front() + 1, -1);
 
         subsets(S, count, selected, 0, result);
         return result;
@@ -281,7 +281,7 @@ \section{Permutations} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \subsection{next_permutation()}
 \label{sec:next-permutation}
-偷懒的做法，可以直接使用\fn{std::next_permutation}。如果是在OJ网站上，可以用这个API偷个懒；如果是在面试中，面试官肯定会让你重新实现。
+偷懒的做法，可以直接使用\fn{next_permutation}。如果是在OJ网站上，可以用这个API偷个懒；如果是在面试中，面试官肯定会让你重新实现。
 
 \subsubsection{代码}
 \begin{Code}
@@ -290,11 +290,11 @@ \subsubsection{代码}
 public:
     vector<vector<int> > permute(vector<int> &num) {
         vector<vector<int> > result;
-        std::sort(num.begin(), num.end());
+        sort(num.begin(), num.end());
 
         do {
             result.push_back(num);
-        } while(std::next_permutation(num.begin(), num.end()));
+        } while(next_permutation(num.begin(), num.end()));
         return result;
     }
 };
@@ -377,7 +377,7 @@ \subsubsection{代码}
 class Solution {
 public:
     vector<vector<int> > permute(vector<int>& num) {
-        std::sort(num.begin(), num.end());
+        sort(num.begin(), num.end());
 
         vector<vector<int>> result;
         vector<int> p(num.size(), 0);  // 中间结果
@@ -447,19 +447,19 @@ \subsubsection{代码}
 class Solution {
 public:
     vector<vector<int> > permuteUnique(vector<int>& num) {
-        std::sort(num.begin(), num.end());
+        sort(num.begin(), num.end());
 
         unordered_map<int, int> count_map; // 记录每个元素的出现次数
-        std::for_each(num.begin(), num.end(), [&count_map](int e) {
+        for_each(num.begin(), num.end(), [&count_map](int e) {
             if (count_map.find(e) != count_map.end())
                 count_map[e]++;
             else
                 count_map[e] = 1;
         });
 
         // 将map里的pair拷贝到一个vector里
-        std::vector<pair<int, int> > elems;
-        std::for_each(count_map.begin(), count_map.end(),
+        vector<pair<int, int> > elems;
+        for_each(count_map.begin(), count_map.end(),
                 [&elems](const pair<int, int> &e) {
                     elems.push_back(e);
                 });
@@ -474,7 +474,7 @@ \subsubsection{代码}
 
 private:
     size_t n;
-    typedef std::vector<pair<int, int> >::const_iterator Iter;
+    typedef vector<pair<int, int> >::const_iterator Iter;
 
     void permute(Iter first, Iter last, vector<int> &p,
             vector<vector<int> > &result) {

C++/chapBruteforce.tex

@@ -632,7 +632,7 @@ \subsubsection{代码}
 class Solution {
 public:
     vector<vector<int> > combinationSum(vector<int> &nums, int target) {
-        std::sort(nums.begin(), nums.end());
+        sort(nums.begin(), nums.end());
         vector<vector<int> > result; // 最终结果
         vector<int> intermediate; // 中间结果
         dfs(nums, target, 0, intermediate, result);
@@ -700,7 +700,7 @@ \subsubsection{代码}
 class Solution {
 public:
     vector<vector<int> > combinationSum2(vector<int> &nums, int target) {
-        std::sort(nums.begin(), nums.end()); // 跟第 50 行配合，
+        sort(nums.begin(), nums.end()); // 跟第 50 行配合，
                                              // 确保每个元素最多只用一次
         vector<vector<int> > result;
         vector<int> intermediate;

C++/chapDFS.tex

@@ -37,7 +37,7 @@ \subsubsection{代码}
     int minimumTotal (vector<vector<int>>& triangle) {
         for (int i = triangle.size() - 2; i >= 0; --i)
             for (int j = 0; j < i + 1; ++j)
-                triangle[i][j] += std::min(triangle[i + 1][j],
+                triangle[i][j] += min(triangle[i + 1][j],
                         triangle[i + 1][j + 1]);
 
         return triangle [0][0];
@@ -320,13 +320,13 @@ \subsubsection{代码}
         vector<int> g(n, 0);
 
         for (int i = 1, valley = prices[0]; i < n; ++i) {
-            valley = std::min(valley, prices[i]);
-            f[i] = std::max(f[i - 1], prices[i] - valley);
+            valley = min(valley, prices[i]);
+            f[i] = max(f[i - 1], prices[i] - valley);
         }
 
         for (int i = n - 2, peak = prices[n - 1]; i >= 0; --i) {
-            peak = std::max(peak, prices[i]);
-            g[i] = std::max(g[i], peak - prices[i]);
+            peak = max(peak, prices[i]);
+            g[i] = max(g[i], peak - prices[i]);
         }
 
         int maxProfit = 0;
@@ -517,7 +517,7 @@ \subsubsection{分析}
 
 剪枝可以五花八门，要充分观察，充分利用信息，找到能让节点提前返回的条件。例如，判断两个字符串是否互为scamble，至少要求每个字符在两个字符串中出现的次数要相等，如果不相等则返回false。
 
-加缓存，可以用数组或HashMap。本题维数较高，用HashMap，\fn{std::map}和\fn{std::unordered_map}均可。
+加缓存，可以用数组或HashMap。本题维数较高，用HashMap，\fn{map}和\fn{unordered_map}均可。
 
 既然可以用记忆化搜索，这题也一定可以用动规。设状态为\fn{f[i][j][k]}，表示长度为$i$，起点为\fn{s1[j]}和起点为\fn{s2[]}两个字符串是否互为scramble，则状态转移方程为
 \begin{Code}
@@ -573,7 +573,7 @@ \subsubsection{代码}
 
         // 剪枝，提前返回
         int A[26]; // 每个字符的计数器
-        std::fill(A, A + 26, 0);
+        fill(A, A + 26, 0);
         for(int i = 0; i < length; i++) A[*(first1+i)-'a']++;
         for(int i = 0; i < length; i++) A[*(first2+i)-'a']--;
         for(int i = 0; i < 26; i++) if (A[i] != 0) return false;
@@ -637,7 +637,7 @@ \subsubsection{代码}
 template<> struct hash<Key> {
     size_t operator()(const Key & x) const {
         Iterator first1, last1, first2;
-        std::tie(first1, last1, first2) = x;
+        tie(first1, last1, first2) = x;
 
         int result = *first1;
         result = result * 31 + *last1;

C++/chapDynamicProgramming.tex

@@ -173,8 +173,8 @@ \subsubsection{代码}
         int cur_min = prices[0]; // 当前最小
 
         for (int i = 1; i < prices.size(); i++) {
-            profit = std::max(profit, prices[i] - cur_min);
-            cur_min = std::min(cur_min, prices[i]);
+            profit = max(profit, prices[i] - cur_min);
+            cur_min = min(cur_min, prices[i]);
         }
         return profit;
     }
@@ -255,14 +255,14 @@ \subsubsection{代码}
     int lengthOfLongestSubstring(string s) {
         const int ASCII_MAX = 26;
         int last[ASCII_MAX]; // 记录字符上次出现过的位置
-        std::fill(last, last + ASCII_MAX, -1); // 0也是有效位置，因此初始化为-1
+        fill(last, last + ASCII_MAX, -1); // 0也是有效位置，因此初始化为-1
         int len = 0, max_len = 0;
         for (size_t i = 0; i < s.size(); i++, len++) {
             if (last[s[i] - 'a'] >= 0) {
                 max_len = max(len, max_len);
                 len = 0;
                 i = last[s[i] - 'a'] + 1;
-                std::fill(last, last + ASCII_MAX, -1);   // 重新开始
+                fill(last, last + ASCII_MAX, -1);   // 重新开始
             }
             last[s[i] - 'a'] = i;
         }

C++/chapGreedy.tex

@@ -223,8 +223,8 @@ \subsubsection{代码}
         const int ASCII_MAX = 256;
         int appeared_count[ASCII_MAX];
         int expected_count[ASCII_MAX];
-        std::fill(appeared_count, appeared_count + ASCII_MAX, 0);
-        std::fill(expected_count, expected_count + ASCII_MAX, 0);
+        fill(appeared_count, appeared_count + ASCII_MAX, 0);
+        fill(expected_count, expected_count + ASCII_MAX, 0);
 
         for (size_t i = 0; i < T.size(); i++) expected_count[T[i]]++;
 
@@ -357,7 +357,7 @@ \subsubsection{代码}
         bool started = false; // 用于跳过前导0
         for (auto i = elems.rbegin(); i != elems.rend(); i++) {
             if (started) { // 如果多余的0已经都跳过，则输出
-                result << std::setw(RADIX_LEN) << std::setfill('0') << *i;
+                result << setw(RADIX_LEN) << setfill('0') << *i;
             } else {
                 result << *i;
                 started = true; // 碰到第一个非0的值，就说明多余的0已经都跳过

C++/chapImplement.tex

@@ -54,8 +54,8 @@ \subsubsection{代码}
     OutIt removeDuplicates(InIt first, InIt last, OutIt output) {
         while (first != last) {
             *output++ = *first;
-            first = std::find_if(first, last,
-                    std::bind1st(std::not_equal_to<int>(), *first));
+            first = find_if(first, last,
+                    bind1st(not_equal_to<int>(), *first));
         }
 
         return output;

C++/chapLinearList.tex

@@ -153,8 +153,8 @@ \subsubsection{代码}
     string addBinary(string a, string b) {
         string result;
         const size_t max_len = a.size() > b.size() ? a.size() : b.size();
-        std::reverse(a.begin(), a.end());
-        std::reverse(b.begin(), b.end());
+        reverse(a.begin(), a.end());
+        reverse(b.begin(), b.end());
         int carry = 0;
         for (size_t i = 0; i < max_len; i++) {
             const int ai = i < a.size() ? a[i] - '0' : 0;
@@ -260,7 +260,7 @@ \subsubsection{代码}
     string longestPalindrome(string s) {
         const int len = s.size();
         int f[len][len];
-        memset(f, 0, len * len * sizeof(int)); //TODO: std::fill, fill_n
+        memset(f, 0, len * len * sizeof(int)); //TODO: fill, fill_n
         int maxL = 1, start = 0;  // 最长回文子串的长度，起点
 
         for (size_t i = 0; i < s.size(); i++) {