存储IP地址
- 给出一个字符串，仅包含数字位，返回可能的IP地址组合。比如给出字符串"25525511135"，返回["255.255.11.135", "255.255.111.35"]，顺序是无关的。
- 思路：关于IP地址的规则：如果字符串的长度大于12或者小于4，都不是合法的IP地址，IP地址共有4个字段，每一个字段都是0~255之间的整数，但是在字符串中，不可以出现诸如"255.025.100.0"这种地址，因为第二字段"025"的"0"会被省去，但是最后一位"0"却是允许的。仔细地考虑这些规则，建立一个函数，判断一个字符串是否是合法的num位IP地址，然后：s[1...n]间所有合法的4位IP地址就是：s[1]是合法的，加上s[2...n]构成的所有合法的3位IP地址……以此类推。
- 实现：
-
class Solution { public: vector<string> restoreIpAddresses(string s) { return ipAddresses(s, 0, 4); } vector<string> ipAddresses(const string& s, int start, int num){ int n = s.length() - start; vector<string> rslt; if(n > num*3 || n < num){ return rslt; } if(num == 1){ string ts = s.substr(start); if(validNum(ts)){ rslt.push_back(ts); } } else{ // num=2,3,4 int m = 3>n ? n : 3; for(int i=1; i<=m; i++){ string ts = s.substr(start, i); vector<string> fss = ipAddresses(s, start+i, num-1); if(validNum(ts)){ for(int j=0; j<fss.size(); j++){ rslt.push_back(ts+"."+fss[j]); } } } return rslt; } } bool validNum(const string& s){ if(s.length() == 0){ return false; } if(s[0]=='0' && s.length()!=1){ return false; } stringstream ss; ss << s; int fld; ss >> fld; if(fld <= 255 && fld >= 0){ return true; } else{ return false; } } };
解码
- 某种消息包含了A-Z的字符，该消息使用了以下密码表加密：
'A' -> 1 'B' -> 2 ... 'Z' -> 26
给出一则加密后的消息，试图给出所有可能的明文的种树，比如给出字符串"12"，返回2，因为该字符串可被解码为两种明文："AB"或"L"。11
- 思路：仍然是动态规划，而且比较简单。建立一个数组nd，nd[i]表示字符串的前i+1位s[0...i]可被解码的种类数，nd[p]的取值可以根据nd[p-1]和nd[p-2]，以及相关的细小规则给出。
- 实现：
-
class Solution { public: int numDecodings(string s) { int n = s.length(); if(n==0){ return 0; } vector<int> nd(n+1, 0); nd[0]=1; if(n>=1){ nd[1]= s[0]=='0' ? 0 : 1; } for(int i=1; i<n; i++){ // To do : set nd[i+1] if(s[i]=='0'){ if(s[i-1]=='1' || s[i-1]=='2'){ nd[i+1] = nd[i-1]; } else{ nd[i+1] = 0; } } else{ // s[i] != 0 if(s[i-1]=='0'){ nd[i+1] = nd[i]; } else if(s[i-1]=='1'){ nd[i+1] = nd[i] + nd[i-1]; } else if(s[i-1]=='2'){ if(s[i]>'6'){ nd[i+1] = nd[i]; } else if(s[i]<='6'){ nd[i+1] = nd[i] + nd[i-1]; } } else{ nd[i+1] = nd[i]; } } } return nd[n]; } };
灰色编码排列
- 灰色编码排列是一种二进制的编码方式，两个连续的元素只有一个bit有差异。给出一个整数n，表示数据元素的位数，然后返回整个灰色编码排列。比如，给出数字2，返回序列[0,1,3,2]，因为灰色编码如下：
00 - 0 01 - 1 11 - 3 10 - 2
- 思路：还是很简单的，生成n位的灰色编码排列，先生成n-1位的排列（$2^n$个元素），然后，先用0接在n-1位的排列每个元素的最前面，然后再用1做相同的事情，最后将两个排列的元素接在一起。需要注意的是：为了使变化只有1位，所以用0接在n-1位排列和用1接n-1位排列时，n-1位的排列的顺序应当是相反的，这样，用0接n-1位排列的结果的最后一个元素，和用1接的最后一个元素，它们才相差1位，那就是第一位（0和1）。至于是先用0接还是先用1接，其实是无所谓的。
- 实现：
class Solution { public: vector<int> grayCode(int n) { int x1=0; int x2=1; vector<int> gc; if(n==0){ gc.push_back(0); } if(n==1){ gc.push_back(x1); gc.push_back(x2); } if(n>1){ vector<int> tc = grayCode(n-1); for(int i=0; i<tc.size(); i++){ gc.push_back(pow(2,n-1)*x1+tc[i]); } for(int i=tc.size()-1; i>=0; i--){ gc.push_back(pow(2,n-1)*x2+tc[i]); } } return gc; } };
两个已排序数组的中位数
- 在代价O(log(m+n))内找到两个已排序数组元素的中位数。
- 思路：假设两个已排序数组分别为 $A\{a_{1},a_{2}...a_{n}\}$ 和 $B\{b_{1},b_{2}...b_{m}\}$。取 $A$ 和 $B$ 的中位数 $a_{mid-A}$ 和 $b_{mid-B}$ 并比较大小：如果 $a_{mid-A}$ 比 $b_{mid-B}$ 小，那么数组 $A$ 的前半部分不可能包含中位数了，数组 $B$ 的后半部分也不可能包含中位数，因此砍掉 $A$ 的前 $x$ 个元素和 $B$ 的后 $x$ 个元素（$x$ 为 数组 $A$ 中的前半部分的元素个数 和 数组 $B$ 中的后半部分的元素个数 中的较小者）。
- 实际用代码实现的时候，考虑了数组 $A$ 和 $B$ 的奇偶性，如果某个数组有偶数个元素，就选出两个中位数，并作一些易于理解但更细致的处理，比如：当具有偶数个元素的数组 $A$ 的较小中位数都比具有奇数个元素的数组 $B$ 的中位数都大的时候，才符合 $A$ 的中位数大于 $B$ 的中位数这样的条件。
- 实现：
int findMedianSortedArrays(int A[], int m, int B[], int n) { int lenA = m/2; int lenB = n/2; int len = lenA<lenB?lenA:lenB; bool frontcutA; if (m%2==1 && n%2==1){ int midA = m/2; int midB = n/2; if (A[midA]<B[midB]){frontcutA = true;} if (A[midA]>B[midB]){frontcutA = false;} if (A[midA]==B[midB]){return A[midA];} } if (m%2==1 && n%2==0){ int midA = m/2; int midB1 = n/2-1;int midB2 = n/2; if (A[midA]<B[midB1]){frontcutA = true;} if (A[midA]>B[midB2]){frontcutA = false;} if (A[midA]>=B[midB1] && A[midA]<=B[midB2]){return A[midA];} } if (m%2==0 && n%2==1){ int midA1 = m/2-1;int midA2 = m/2; int midB = n/2; if (A[midA2]<B[midB]){frontcutA = true;} if (A[midA1]>B[midB]){frontcutA = false;} if (A[midA1]<=B[midB] && A[midA2]>=B[midB]){return B[midB];} } if (m%2==0 && n%2==0){ int midA1 = m/2-1;int midA2 = m/2; int midB1 = n/2-1;int midB2 = n/2; if (A[midA2]<B[midB1]){frontcutA = true;} if (A[midA1]>B[midB2]){frontcutA = false;} else{return A[midA1]>B[midB1]?A[midA1]:B[midB1];} } if (frontcutA){ return findMedianSortedArrays(A+len, m-len, B, n-len); } else{ return findMedianSortedArrays(A, m-len, B+len, n-len); } }
扭曲的字符串
- 给定一个字符串，这个字符串可以被分割成一棵二叉树，树的每个叶子节点都是单个字母，比如字符串"great"可以被分为：
great / \ gr eat / \ / \ g r e at / \ a t
对任意的非叶子节点，交换左子树和右子树，能够得到一个新的字符串。该操作允许进行任意次，比如这样一个字符串"rgtae"：
rgtae / \ rg tae / \ / \ r g ta e / \ t a
就可以先通过交换eat节点（的左右子树），然后交换at节点，最后交换gr节点来生成。
现在给定字符串s1和s2，判断是否能够通过这种操作来将s1转换为s2。 -
思路：
-
首先，如果两个字符串的长度不一样，或者长度一样但是包含的字母不一样（这一点通过排序之后比较实现），那么是没可能转换成功的，这是显见的。
-
其次，如果两个字符串包含相同的字母，也不一定能够成功，比如"abcd"和"bdac"（不信你可以试试）。
-
在这种情况下，可以转换成功地条件是：存在这么一个数p<n（字符串的长度），使得（s1的前p位能够转换为s2的前p位，而且s1的后n-p位能够转换为s2的后n-p位）或者（s1的前p位能够转换为s2的后p位，而且s1的后n-p位能够转换为s2的前n-p位）：如果存在这么一个p，那么就成功了。
-
- 实现：
-
class Solution { public: bool isScramble(string s1, string s2) { if (s1.length()!=s2.length()){ return false; } int n = s1.length(); return isScramble(s1, s2, 0, 0, n); } bool isScramble(const string& s1, const string& s2, int n, int m, int p){ if (!hasSameLetters(s1, s2, n, m, p)){ return false; } if(p==2 || p==1){ return true; } for (int i=0; i<p-1; i++){ if(isScramble(s1, s2, n, m, i+1) && isScramble(s1, s2, n+i+1, m+i+1, p-i-1)){ return true; } if(isScramble(s1, s2, n, m+p-i-1, i+1) && isScramble(s1, s2, n+i+1, m, p-i-1)){ return true; } } return false; } bool hasSameLetters(const string& s1, const string& s2, int n, int m, int p){ vector<char> v1, v2; for (int i=0; i<p; i++){ v1.push_back(s1[n+i]); v2.push_back(s2[m+i]); } sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); return v1==v2; } };
分割链表
- 给出一个单链表，和一个值x，将单链表分为前后两部分，前一部分的所有元素都小于x，后一部分的所有元素都大于等于x，而且前后部分元素的相对位置和原链表一致。比如给出链表1->4->3->2->5->2和值3，返回链表1->2->2->4->3->5。
- 思路：既然没有要求原地排序，而且还需要元素相对位置和原链表一致，那这道题实在太简单了，直接遍历一遍链表，按照条件复制到两个链表中，再将两个链表接起来就是。
- 实现：
class Solution { public: ListNode *partition(ListNode *head, int x) { ListNode* h1 = new ListNode(0); ListNode* h2 = new ListNode(0); ListNode* t1 = h1, *t2 = h2, *p = head; while(p!=NULL){ if(p->val<x){ t1->next = new ListNode(p->val); t1 = t1->next; } else{ t2->next = new ListNode(p->val); t2 = t2->next; } p=p->next; } t1->next=h2->next; return h1->next; } };