算法 on ZRJ | 学习笔记

背包问题

Thu, 19 Oct 2017 16:53:29 +0800

http://www.lintcode.com/zh-cn/problem/backpack-vi/

给出一个都是正整数的数组 nums，其中没有重复的数。从中找出所有的和为 target 的组合个数。

注意事项

一个数可以在组合中出现多次。数的顺序不同则会被认为是不同的组合。

样例给出 nums = [1, 2, 4], target = 4 可能的所有组合有：

[1, 1, 1, 1] [1, 1, 2] [1, 2, 1] [2, 1, 1] [2, 2] [4] 返回 6

#include <stdio.h>
#include <string>
#include <vector>
#include <algorithm>

class Solution {
public:
    /*
    * @param nums: an integer array and all positive numbers, no duplicates
    * @param target: An integer
    * @return: An integer
    */
    int backPackVI(std::vector<int> &nums, int target) {
        // write your code here
        std::vector<int> dp(target + 1);
        dp[0] = 1;
        for (int i = 1; i <= target; i++) {
            for (int j = 0; j < nums.size(); j++) {
                if (nums[j] <= i) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }

};

int main(int, char**) {
    Solution solution;
    std::vector<int> nums = { 1, 2, 4 };
    int target = 4;
    printf("%d\n", solution.backPackVI(nums, target));
    return 0;
}

36 进制

Fri, 07 Aug 2015 17:30:39 +0800

看到同事桌上有一份面试题，有一个 36 进制运算的题目，手贱敲了一下，不调真的不好做啊

#include <stdio.h>
#include <string>
#include <algorithm>
#include <math.h>

int convert_36_10(std::string strNum) {
	std::reverse(strNum.begin(), strNum.end());
	int n = 0;
	for (int i = 0; i < strNum.size(); i++) {		
		char c = strNum[i];
		if (c >= '0' && c <= '9') {
			n += (c - '0') * pow(36.0, i);
		} else if (c >= 'A' && c <= 'Z') {
			n += (10 + c - 'A') * pow(36.0, i);
		}
	}
	return n * ((strNum[strNum.size() - 1] == '-') ? -1 : 1);
}

std::string convert_10_36(int n) {
	if (n == 0) {
		return "0";
	}
	std::string strNum;
	int s = n > 0;
	n = abs(n);
	while (n) {
		int m = n % 36;
		char c = '-';
		if (m < 10) {
			c = m + '0';
		} else {
			c = m-10 + 'A';
		}
		strNum = c + strNum;
		n /= 36;
	}
	return s ? strNum : "-"+strNum;
}

std::string add(std::string strNum1, std::string strNum2) {
	int n1 = convert_36_10(strNum1);
	int n2 = convert_36_10(strNum2);
	return convert_10_36(n1 + n2);
}

std::string min(std::string strNum1, std::string strNum2) {
	int n1 = convert_36_10(strNum1);
	int n2 = convert_36_10(strNum2);
	return convert_10_36(n1 - n2);
}

int main() {
	while (1) {
		char szNum1[16] = {0}, szNum2[16] = {0};
		scanf("%s%s", szNum1, szNum2);
		printf("%s + %s = %s\n", szNum1, szNum2, add(szNum1, szNum2).c_str());
		printf("%s - %s = %s\n", szNum1, szNum2, min(szNum1, szNum2).c_str());
	}	
	return 0;
}

Linked List Cycle

Mon, 20 Oct 2014 16:24:57 +0800

所谓拳不离手曲不离口，算法和基础不能丢。

话说三藏师徒四人辞别女儿国，再上西行路，今天来到。。。啊呸，扯远了。。

今天来看这个，https://oj.leetcode.com/problems/linked-list-cycle/，题目是这么说的

Given a linked list, determine if it has a cycle in it.

Follow up: Can you solve it without using extra space?

这题原本是简单，他页面上提供了一个在线的编辑器，带语法高亮和自动补全，我三分钟直接在线写完，一次性提交就编译通过同时 Accepted，想想上次刷 OJ 还是很久之前了，如今依然没有手生，还是很开心的，土豪解法如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <set>
class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* curr = head;
        while (curr) {
            if (viewed.find(curr) != viewed.end()) {
                return true;
            }
            viewed.insert(curr);
            curr = curr->next;
        }
        return false;
    }
    std::set<ListNode*> viewed;
};

类和函数是他给好的，我们要做的就是在类里面填空而已。

可以看到，这个解法不论是在时间还是空间上，都是土豪，何止土豪，那是相当土豪。不过，实际项目中，其实这么写是可以的，稳定，不出错，可维护性高。

不过，原题里还有这么一句，Can you solve it without using extra space?，这个很明显就是见功夫的地方了，要抠时间和空间，时间上是没啥可压缩了，至少也要遍历一次，空间上嘛，他要求没有额外空间，怎么搞呢，想了想，想起来之前看书的时候看到这个题，当时说的是，用两个指针，一个每次走一步，一个每次走两步，如果这两个指针遇上了，那么就说明有环，具体写起来，可以这么写：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
            if (slow == fast) {
                return true;
            }
        }
    }
};

又是一次 Accepted，我都怀疑是不是用例太弱了。。

需要注意的是，如果把最后的两个 if 判断对调位置，变成这样

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (slow == fast) {
                return true;
            }
            if (fast == NULL && slow == NULL) {
                return false;
            }
        }
    }
};

那就会导致 WA，具体为什么可以想想，不难想出来。

不过，这个题目还有一个变式，要求找出环的入口节点，题目在这里，https://oj.leetcode.com/problems/linked-list-cycle-ii/，这个题的解法很是有技巧，分析思路可以看到这里，http://blog.reetsee.com/archives/187

我们设链表的无环的部分长度为L1，即有L1个节点，注意，这个L1是包括环的入口节点的。然后让环的长度是L2，这个L2也是包括环的入口节点。这个时候，p1和p2的交点如图所示，交点距离环的入口节点为a（从入口节点沿着行走方向走到交点），即在环的入口节点后面的第a个节点，就是交点，我用红色标记出a。

然后我们来考察一下L1，L2，a，以及n（n是走过的步数，不是走过的节点数，p1一步一个节点，p2一步两个节点）的关系。

忘记说一点了，我们可以明确的是，p1在进入环后，走了不到一圈就在交点处和p2重合，為什麼肯定没有走完一圈？因为p1在进入环的时候，p2和p1之间的距离（沿着行走方向）至多为 L2-1，不可能超过L2-1，因为环的大小也才只有L2 。p2追赶p1，最多只需要走L2-1步，因为每走一步，p1和p2的相对距离减小1，那么p1最多只走了L2-1步，就是最多只经过了L2-1个节点，不可能走完一圈。

现在可以列公式了：

L1+a=n #1 //n是p1走过的节点数 L1+k*L2+a=2*n #2 //2*n这个是p2走过的节点数，其中的k表示p2可能在环里面走了k圈，k>=1 由#2式减去#1式，有：

k*L2 = n #3 同时由#1和#3得到：

L1+a = k*L2 #4 接着由#4就得到了如下式：

L1 = k*L2 – a = (k-1)*L2 + (L-a) 得到这条式子就拨得云开见月明啊有木有，因为(L-a)表示的是交点与环入口的距离（从交点沿着行走方向到环入口），然后(k-1)是>=0的，因为p2在环中至少绕了一圈，这样我们就发现：L1的长度 = 环长度的整数倍 + 交点与环入口的距离

也就是说，p1再走L1步就可以达到环的入口。问题是L1不是已知的，没关系，在表头设置一个p3指针，p3每步前进一个节点。让p1和p3同时走，每次走1步，等p3和p1重合了，就是到了环口的位置了。Problem solved~

很自然的，写出下面的代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

但是这样是 WA 的，OJ 很仁慈的把错误说出来了

Input: {1,2}, tail connects to node index 0 Output: tail connects to node index 1 Expected: tail connects to node index 0

也就是说，考虑这种情况：整个链表只有两个节点，并且这两个节点构成一个环，那么上述代码就出错了，打个补丁：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head), *p1(head);
        while (1) {
            if (slow) {
                slow = slow->next;
            }
            if (fast) {
                fast = fast->next;
                if (fast) {
                    fast = fast->next;
                }
            }
            if (fast == NULL && slow == NULL) {
                return NULL;
            }
            if (slow == fast) {
                if (slow == head) {
                    return head;
                }
                while (1) {
                    slow = slow->next;
                    p1 = p1->next;
                    if (p1 == slow) {
                        return p1;
                    }
                }
            }
        }
    }
};

得以 Accepted，而其实，上述的代码，是可以进一步改的，注意到我们外面的那个循环，为了保守起见，是等慢指针遍历到尾，才退出的，其实根本没必要，只要快指针遇到 NULL 了，就可以撤了，如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast(head), *slow(head);
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast) {
                ListNode *p(head);
                while (p != slow) {
                    slow = slow->next;
                    p = p->next;
                }
                return p;
            }
        }
        return NULL;
    }
};

-——————————-

2014-11-21 09:43:45 update

另外的一个思路是，每次前进一个节点，就把这个节点的 next 指针指向 head，这样，如果发现在某个节点被处理之前，就已经指向 head，那么就可以知道有环了，而且这个方法还可以天然的找出环的入口，不需要额外空间，缺点是破坏链表，一次处理之后，链表就被破坏的面目全非了。

这个思路尚未经过实际代码验证。

历史评论

wanax (2015-01-20 14:38:47):

真有闲情逸致….

Jon Bently 一种快排的写法

Sun, 30 Mar 2014 18:20:59 +0800

看到知乎上有这个讨论，程序员能20分钟徒手写出一个没bug的快速排序吗？

void quicksort(int l, int u){
    int i, m;
    if(l >= u) return;
    m = l;
    for(i = l+1; i<= u; i++)
        if(x[i] < x[l]) // buggy!
            swap(++m, i);

    swap(l, m);

    quicksort(l, m-1);
    quicksort(m+1, u);

}

还有何磊的解释

上面是他在 beautiful code 上的代码。最核心的部分就是开始的那个for循环和swap了（paritition），这要怎么背呢？当然是用循环不变式了！ [l+1, m] 位置保存着当前已处理元素之中所有的小于pivot的元素 i指向的是下一个待处理的元素第l个元素是pivot 循环开始时，[l+1, m]是空集，已处理元素也是空的，所以循环不变式成立。 for循环每轮把i加了1，这样就有可能破坏循环不变式，怎么办呢，当然是：在i加1之前，如果发现当前i指向的值小等于pivot，就将m自增1，并且和i指向的元素交换。这样，循环不变式又成立啦。在for循环结束后，循环不变式依然是成立的（根据数学归纳法~）那么，它告诉了我们什么性质呢？ [l+1, m]之间包含了l 到 u 之间的小于 pivot 的元素，且第l个元素是pivot。于是，我们只要将第l个元素和第m个元素交换，就完成了partition的操作，即：pivot在第m个元素上，m元素之前的值都小于pivot，之后的值都大等于pivot。

非常简洁，非常酷炫，但是有点bug（注意我注释的那一行）这个partition在大量duplicate key的情况下，会把这些key全部放到左边或者右边。导致不公平的切分。

看懂理解之后，实在是太惊艳了，回想之前的快排，是这么写的。。http://zrj.me/archives/229，真是挫啊。。。

练手代码白板

Sun, 02 Mar 2014 17:14:15 +0800

先来一个简单的 list

#include <stdio.h>

class ListNode {
public:
	ListNode(int n) {
		this->n = n;
		this->pNext = NULL;
	}
	int n;
	ListNode* pNext;
};

class List {
public:
	ListNode* pHead;
	List(ListNode* pHead) {
		this->pHead = pHead;
	}
	List* add(ListNode* node) {
		ListNode* pCurr = pHead;
		while (pCurr->pNext) {
			pCurr = pCurr->pNext;
		}	
		pCurr->pNext = node;
		return this;
	}
	List* reverse() {
		ListNode* pCurr = pHead;
		ListNode* pNext = pCurr->pNext;
		pHead->pNext = NULL;
		while (pNext) {
			ListNode* pTmp = pNext->pNext;
			pNext->pNext = pCurr;
			pCurr = pNext;
			pNext = pTmp;
		}
		pHead = pCurr;
		return this;
	}
	List* sort() {
		ListNode* pOldHead = pHead->pNext;		
		ListNode* pNewHead = pHead;
		pNewHead->pNext = NULL;
		while (pOldHead) {
			ListNode *pNewPre = NULL, 
				*pNewCurr = pNewHead, 
				*pTmp = pOldHead->pNext;
			for (; pNewCurr && pNewCurr->n <= pOldHead->n; 
				pNewPre = pNewCurr, pNewCurr = pNewCurr->pNext);
			if (pNewCurr == pNewHead) {
				pOldHead->pNext = pNewHead;
			} else {
				pNewPre->pNext = pOldHead;
				pOldHead->pNext = pNewCurr;
			}
			pOldHead = pTmp;
		}
		pHead = pNewHead;
		return this;
	}
	List* print() {
		ListNode* pCurr = pHead;
		while (pCurr) {
			printf("%d -> ", pCurr->n);
			pCurr = pCurr->pNext;
		}
		printf("NULL\n");
		return this;
	}
	~List() {
		ListNode* pCurr = pHead;
		while (pCurr) {
			ListNode* pNext = pCurr->pNext;
			printf("deleting %d\n", pCurr->n);
			delete pCurr;
			pCurr = pNext;
		}
	}
};

int main() {
	List* l = new List(new ListNode(0));
	l->add(new ListNode(2))
		->add(new ListNode(3))
		->add(new ListNode(1))
		->add(new ListNode(4))
		->add(new ListNode(0))
		->add(new ListNode(5));
	l->print();
	l->sort();
	l->print();
	delete l;
	return 0;
}

几个排序

#include <stdio.h>

void print(int* pArr, int n) {
	while (n--) {
		printf("%d\t", *pArr);
		pArr++;
	}
	printf("\n");
}

inline swap(int* pA, int* pB) {
	int tmp = *pA;
	*pA = *pB;
	*pB = tmp;
}

void bubbleSort(int* pArr, int n) {
	for (int i = 0; i < n; i++) {
		for (int j = 1; j < n - i; j++) {
			if (pArr[j-1] > pArr[j]) {
				swap(&pArr[j-1], &pArr[j]);
			}
		}
	}
}

void selectSort(int* pArr, int n) {
	for (int i = 0; i < n; i++) {
		int min = i;
		for (int j = i; j < n; j++) {
			if (pArr[j] < pArr[min]) {
				swap(&pArr[j], &pArr[min]);
			}
		}
	}
}

void quickSort(int* pArr, int i, int j) {
	int a = i, b = j, p = (i + j) / 2;
	while (a <= b) {
		while (pArr[a] < pArr[p]) {
			a++;
		}
		while (pArr[b] > pArr[p]) {
			b--;
		}
		if (a <= b) {
			swap(&pArr[a], &pArr[b]);
			a++;
			b--;
		}
	}
	if (i < b) {
		quickSort(pArr, i, b);
	}
	if (a < j) {
		quickSort(pArr, a, j);
	}
}

int main() {
	int a[] = {5, 2, 1, 4, 3, 0, 0};
	int len = sizeof(a)/sizeof(int);
	print(a, len);
	//bubbleSort(a, len);
	//selectSort(a, len);
	quickSort(a, 0, len);
	print(a, len);
	return 0;
}

再来，字符集差集

#include <bitset>
#include <vector>

class CCharSubSet {
public:
    char* a;
    char* b;
    std::vector<char> c;
    
    CCharSubSet() {
        a = "abcd";
        b = "bd";
    }
    
    int Sub() {
        std::bitset<256> bitsetA, bitsetB;
        bitsetA.reset();
        bitsetB.reset();
        for (size_t i = 0; i < strlen(a); i++) {
            bitsetA[a[i] + 128] = true;
        }
        for (size_t i = 0; i < strlen(b); i++) {
            bitsetB[b[i] + 128] = true;
        }
        bitsetA ^= bitsetB;
        for (int i = 0; i < 256; i++) {
            if (bitsetA[i]) {
                c.push_back(i - 128);
            }
        }
        for (size_t i = 0; i < c.size(); i++) {
            printf("%c\n", c[i]);
        }
        return 0;
    }
};


int main() {
    CCharSubSet oCharSubSet;
    oCharSubSet.Sub();
    return 0;
}

条件找数

#include <bitset>
#include <set>
#include <vector>
#include <map>

class CNumber {
    static const int MAX = 100000;
    std::vector<int> vecPrimeTable;

    int InitPrimeTable() {
        std::bitset<MAX> isPrime;
        isPrime.set();
        isPrime[0] = isPrime[1] = false;
        for (int i = 2; i*i < MAX; i++) {
            if (isPrime[i]) {
                for (int j = i*i; j < MAX; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        for (int i = 2; i < MAX; i++) {
            if (isPrime[i]) {
                vecPrimeTable.push_back(i);
            }
        }
        return 0;
    }

    std::map<int, int> mapDigitalSum;

    int DigitalSumOf(int n) {
        if (mapDigitalSum[n] == 0) {
            int iTmp = n;
            int iSum = 0;
            while (iTmp) {
                iSum += iTmp % 10;
                iTmp /= 10;
            }
            mapDigitalSum[n] = iSum;
        }
        return mapDigitalSum[n];
    }

    std::set<int> setResult;
    
    int Dfs(int iCurr, int iMulti, int iSum) {
        //printf("%d, %d, %d\n", iCurr, iMulti, iSum);
        if (iMulti > MAX || iMulti < 0) {
            return -1;
        }
        if (DigitalSumOf(iMulti) == iSum) {
            setResult.insert(iMulti);
        }
        for (size_t i = 0; i < vecPrimeTable.size(); i++) {
            if (vecPrimeTable[i] < iCurr) {
                continue;
            }
            if (Dfs(vecPrimeTable[i], iMulti * vecPrimeTable[i],
                iSum + DigitalSumOf(vecPrimeTable[i])) == -1) {
                break;
            } 
        }
        return 0;
    }

    int Print() {
        for (std::set<int>::iterator it = setResult.begin();
                it != setResult.end(); it++) {
            printf("%d\n", *it);
        }
        return 0;
    }
    
public:
    int Run() {
        InitPrimeTable();
        Dfs(vecPrimeTable[0], 1, 0);
        Print();
        return 0;
    }
};

int main() {
    CNumber oNumber;
    oNumber.Run();
    return 0;
}

-————————————

2014-3-7 09:16:05 update 字符集差集还可以这么来写

#include <set>
#include <vector>
#include <algorithm>
#include <string>

class CCharSetDiff {
public:
    std::string Diff(std::string strA, std::string strB) {
        std::set<char> setA(strA.begin(), strA.end());
        std::set<char> setB(strB.begin(), strB.end());
        std::vector<char> vecDiff(256);
        std::set_difference(setA.begin(), setA.end(),
            setB.begin(), setB.end(), vecDiff.begin());
        return std::string(vecDiff.begin(), vecDiff.end());         
    }
};

int main() {
    CCharSetDiff oCharSetDiff;
    printf("%s\n", oCharSetDiff.Diff("abcd", "bd").c_str());
    return 0;
}

历史评论

wanax (2014-03-19 16:44:58):

这是新装了VS2013看着PL忍不住玩一下么

ZRJ (2014-03-19 20:14:43):

我还在用 vs 2005,2013 长啥样

wanax (2014-03-20 09:48:49):

蛮好看的都忍不住要装win8来试下了

allen (2014-06-10 19:54:42):

差集的 +128的写法木有看明白，不加不是照样做出来吗？

ZRJ (2014-06-10 20:30:46):

嗯，一般情况是没问题的，但是注意到 a b 两个变量，是声明为 char* 类型，而不是 unsigned char* 类型，所以 a[i] b[i] 的值可能为负，如果为负，用负值作为下标去索引 bitsetA bitsetB 就可能越界

基于 AC 自动机的多模匹配的 map

Thu, 21 Nov 2013 14:59:47 +0800

昨天写了一个 AC 自动机的模版题，现在，我们需要基于这个模版，实现一个多模匹配的 map，具体是这样的，我们给一个 map<string, int>，然后给一个串，要求在这个串里面，把 map 中含有的 key 的 value 都返回出来。

注意到昨天的模版题的实现，是会去改动树本身的，同时也没有做一些内存管理方面的处理，另外的区别是昨天的题是考虑多个相同关键字的，而这个，由于 map 的 key 的唯一性，自然是不允许多个相同的 key 的，那么修改之后如下：

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <string>
#include <queue>
#include <set>

#define CHAR_COUNT 128

class Node {
public:
    Node() {
        memset(this, 0, sizeof(*this));
    }
    char ch;
    Node* fail;
    Node* next[CHAR_COUNT];
    bool end;
    int value;
};

class Trie {
public:
    Node* root;

    Trie() {
        root = new Node();
    }

    ~Trie() {
        clear(root);
    }

    void insert(const char* strKey, int value) {
        Node* p = root;
        for (int i = 0; strKey[i]; i++) {
            char ch = strKey[i];
            if (p->next[ch] == NULL) {
                p->next[ch] = new Node();
            }
            p = p->next[ch];
            p->ch = strKey[i];
        }
        p->end = true;
        p->value = value;
    }

    void build() {
        std::queue<Node*> q;
        q.push(root);
        while ( ! q.empty()) {
            Node* tmp = q.front();
            q.pop();
            for (int i = 0; i < CHAR_COUNT; i++) {
                if (tmp->next[i]) {
                    if (tmp == root) {
                        tmp->next[i]->fail = root;
                    } else {
                        Node* p = tmp->fail;
                        while (p) {
                            if (p->next[i]) {
                                tmp->next[i]->fail = p->next[i];
                                break;
                            }
                            p = p->fail;
                        }
                        if ( ! p) {
                            tmp->next[i]->fail = root;
                        }
                    }
                    q.push(tmp->next[i]);
                }
            }
        }
    }

    std::vector<int> query(const char* str) {
        std::vector<int> result;
        Node* p = root;
        for (int i = 0; str[i]; i++) {
            char ch = str[i];
            while ( ! p->next[ch] && p != root) {
                p = p->fail;
            }
            p = p->next[ch];
            if ( ! p) {
                p = root;
            }
            Node* tmp = p;
            while (tmp != root) {
                if (tmp->end) {
                    result.push_back(tmp->value);
                }
                tmp = tmp->fail;
            }
        }
        return result;
    }

    void clear(Node*& p) {
        if (p) {
            for (int i = 0; i < CHAR_COUNT; i++) {
                clear(p->next[i]);
            }
            delete p;
            p = NULL;
        }
    }
};


int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        Trie trie;
        int n;
        scanf("%d", &n);
        while (n--) {
            std::string keyword;
            int value;
            std::cin>>keyword>>value;
            trie.insert(keyword.c_str(), value);
        }
        trie.build();
        std::string query;
        std::cin>>query;
        std::vector<int> result = trie.query(query.c_str());
        printf("size %d\n", result.size());
        for (std::vector<int>::iterator it = result.begin(); it != result.end(); it++) {
            printf("%d\n", *it);
        }
    }
    return 0;
}

对于这个实现，思路上应该是没有问题，但是，看一下下面这个测试用例。

他的输出却是这个样子的

size 3
11
111
11

嗯，11 这个 value 出现了两次。

让我们来分析一下，模拟程序的运行过程，看看是什么情况。

首先给出失败指针的结果图如上，我们来看看这个失败指针是怎么得出来的。

第 50 行，把 root 节点加入队列（root 节点的失败指针是 NULL），然后进入 51 行开始的队列处理循环
取出 root 节点，根据 56 - 58 行，对 root 节点的所有直接子节点，将其失败指针指向 root，对应图上的失败指针 1。同时 71 行将 root 节点的所有子节点追加入队列。至此，队列中有一个节点，也就是第一个 a 节点。
回到 52 行，取出第一个 a 节点，开始处理。注意到在 54 - 73 行的 for 循环中，tmp 指针是一直不会发生变化的，所以，这个 tmp 指针，可以理解成“当前父节点”，而在此轮循环中，任务就是为这个“当前父节点”的全部非空子节点找好失败指针。那么，对于第一个 a 节点，代码走到 59 行，指针 p 指向第一个 a 节点的失败指针，也就是 root，然后进入 60 - 66 的 while 循环。由于 root 节点有一个字符为 a 的子节点，于是在第一轮的循环中，就为第二个 a 节点找好了失败指针，也就是让第二个 a 节点的失败指针指向第一个 a 节点。
第二个 a 节点成为“当前父节点”，同理，为其子节点（也就是第三个 a 节点）找到的失败指针指向了第二个 a 节点。至此所有失败指针建立完成。

回到 60 - 66 行这个 while 循环，为什么这个循环就能可以建立出正确的失败指针呢。这个 while 循环的原理是：一级一级的沿着失败指针回溯，直到某一个节点的包含有跟“当前父节点”相同字符的子节点（61 行）并把“当前父节点”的对应子节点的失败指针指向这个找到的子节点（62 行）并跳出循环（63 行）或者一直找到空节点（65 行）为止。

那么，这样一来，就可以保证，为“当前父节点”的所有子节点找到的失败指针，指向的节点的字符，都是跟这个子节点一样的，而父节点的失败指针，也在上一轮的 BFS 遍历中，指向了一个跟父节点含有相同字符（或者）跟节点的指针，那么，递归的，就可以保证，从那个找到的失败指针往上走，关键词的字符顺序是跟当前路径下来的字符顺序是能匹配（后缀是匹配的）的，所以，失败指针就能据此正确的建立起来。

然后让我们来看一下查询的过程：

对于第一个字母，走到第一个 a 节点，沿着失败指针找，找到 root，跳出
对于第二个字母，走到第二个 a 节点，然后他的 end 标志是 true 的，于是把这个节点的 value 值 11 加入结果集，沿着失败指针，找到第一个 a 节点，再沿着失败指针，找到 root 节点，跳出
对于第三个字母，走到第三个 a 节点，并发现第三个 a 节点的 end 标志是 true，于是把这个节点的 value 值 111 加入结果集，并继续沿着失败指针，找到第二个 a 节点，发现他是 end 的，于是将 11 加入结果集，再沿着失败指针，找到第一个 a 节点和 root 节点，跳出。

注意到悲剧就在第三步的“沿着失败指针回溯”这个环节上，再回到的了第二个 a 节点那里，昨天那个版本之所以不存在这个问题，是因为他在每次加入之后，都把那个节点的 prefix 置为了 -1 并且在循环的时候检查这个 prefix，但是这样就污染了树的内容，从而不利于多次查询。

那么为什么他这里需要沿着失败指针一直回溯呢？回想到之前建立失败指针的过程，由于一个节点下面，失败指针只有一个，这个指针将会指向第一个被找到的具有相同后缀的节点上，但是，无法排除还有其他相同后缀的节点，而这些节点要怎么去关联起来呢，就靠那个被指向的失败节点的失败指针继续往后了，有点链表的感觉，所以，在查询的时候，也需要沿着这些失败指针，一直回溯，直到找到 root 节点为止。

至此基本上就明白了，至于解决方法，我想到的办法也很简单，其实就是在 end 节点上保存这个 key 的 string，然后查询的时候用一个 map 来存放中间结果就可以了。

修改之后的代码也放一份吧：

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <string>
#include <queue>
#include <map>
#include <set>

#define CHAR_COUNT 128

class Node {
public:
    Node() {
        ch = 0;
        fail = NULL;
        memset(next, NULL, sizeof(next));
        end = false;
        key = "";
        value = 0;
    }
    char ch;
    Node* fail;
    Node* next[CHAR_COUNT];
    bool end;
    std::string key;
    int value;
};

class Trie {
public:
    Node* root;

    Trie() {
        root = new Node();
    }

    ~Trie() {
        clear(root);
    }

    void insert(const char* strKey, int value) {
        Node* p = root;
        for (int i = 0; strKey[i]; i++) {
            char ch = strKey[i];
            if (p->next[ch] == NULL) {
                p->next[ch] = new Node();
            }
            p = p->next[ch];
            p->ch = strKey[i];
        }
        p->end = true;
        p->key.assign(strKey);
        p->value = value;
    }

    void build() {
        std::queue<Node*> q;
        q.push(root);
        while ( ! q.empty()) {
            Node* tmp = q.front();
            q.pop();
            for (int i = 0; i < CHAR_COUNT; i++) {
                if (tmp->next[i]) {
                    if (tmp == root) {
                        tmp->next[i]->fail = root;
                    } else {
                        Node* p = tmp->fail;
                        while (p) {
                            if (p->next[i]) {
                                tmp->next[i]->fail = p->next[i];
                                break;
                            }
                            p = p->fail;
                        }
                        if ( ! p) {
                            tmp->next[i]->fail = root;
                        }
                    }
                    q.push(tmp->next[i]);
                }
            }
        }
    }

    std::map<std::string, int> query(const char* str) {
        std::map<std::string, int> result;
        Node* p = root;
        for (int i = 0; str[i]; i++) {
            char ch = str[i];
            while ( ! p->next[ch] && p != root) {
                p = p->fail;
            }
            p = p->next[ch];
            if ( ! p) {
                p = root;
            }
            Node* tmp = p;
            while (tmp != root) {
                if (tmp->end) {
                    result[tmp->key] = tmp->value;
                }
                tmp = tmp->fail;
            }
        }
        return result;
    }

    void clear(Node*& p) {
        if (p) {
            for (int i = 0; i < CHAR_COUNT; i++) {
                clear(p->next[i]);
            }
            delete p;
            p = NULL;
        }
    }
};


int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        Trie trie;
        int n;
        scanf("%d", &n);
        while (n--) {
            std::string keyword;
            int value;
            std::cin>>keyword>>value;
            trie.insert(keyword.c_str(), value);
        }
        trie.build();
        std::string query;
        std::cin>>query;
        std::map<std::string, int> result = trie.query(query.c_str());
        printf("size %d\n", result.size());
        for (std::map<std::string, int>::iterator it = result.begin(); it != result.end(); it++) {
            printf("%s -> %d\n", it->first.c_str(), it->second);
        }
    }
    return 0;
}

稍微注意一下，由于结构体里面有了 stl 容器 string，所以不能再用 memset 来初始化整个结构体了。

历史评论

wanax (2013-12-03 09:17:24):

虽不明但觉厉…

ZRJ (2013-12-03 10:50:29):

其实这个还是很有应用价值的，例如说，发微博，或者留言的时候，需要敏感词过滤，敏感词可能有成千上万个，一条留言大约两三百个字符，你总不能循环的调用成千上万次的 str find 函数吧，这个时候就要靠这个 ac 自动机了

wanax (2013-12-03 11:24:45):

这个就是那个论文的东西？

ZRJ (2013-12-03 11:52:52):

啥论文。。怎么会扯到论文去了

AC 自动机

Wed, 20 Nov 2013 20:52:19 +0800

hdu 2222 题。。（这题号。。。）http://acm.hdu.edu.cn/showproblem.php?pid=2222

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <string>
#include <queue>

#define CHAR_COUNT 26

class Node {
public:
    Node() {
        memset(this, 0, sizeof(*this));
    }
    char ch;
    Node* fail;
    Node* next[CHAR_COUNT];
    int prefix;
};

class Trie {
public:
    Node* root;

    Trie() {
        root = new Node();
    }

    void insert(const char* str) {
        Node* p = this->root;
        for (int i = 0; str[i]; i++) {
            char ch = str[i]-'a';
            if (p->next[ch] == NULL) {
                p->next[ch] = new Node();
            }
            p = p->next[ch];
            p->ch = str[i];
        }
        p->prefix++;
    }

    void build() {
        std::queue<Node*> q;
        q.push(root);
        while ( ! q.empty()) {
            Node* tmp = q.front();
            q.pop();
            for (int i = 0; i < CHAR_COUNT; i++) {
                if (tmp->next[i]) {
                    if (tmp == root) {
                        tmp->next[i]->fail = root;
                    } else {
                        Node* p = tmp->fail;
                        while (p) {
                            if (p->next[i]) {
                                tmp->next[i]->fail = p->next[i];
                                break;
                            }
                            p = p->fail;
                        }
                        if ( ! p) {
                            tmp->next[i]->fail = root;
                        }
                    }
                    q.push(tmp->next[i]);
                }
            }
        }
    }

    int query(const char* str) {
        int ret = 0;
        Node* p = root;
        for (int i = 0; str[i]; i++) {
            char ch = str[i]-'a';
            while ( ! p->next[ch] && p != root) {
                p = p->fail;
            }
            p = p->next[ch];
            if ( ! p) {
                p = root;
            }
            Node* tmp = p;
            while (tmp != root && tmp->prefix != -1) {
                ret += tmp->prefix;
                tmp->prefix = -1;
                tmp = tmp->fail;
            }
        }
        return ret;
    }
};


int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        Trie trie;
        int n;
        scanf("%d", &n);
        while (n--) {
            std::string keyword;
            std::cin>>keyword;
            trie.insert(keyword.c_str());
        }
        trie.build();
        std::string query;
        std::cin>>query;
        printf("%d\n", trie.query(query.c_str()));
    }
    return 0;
}

这个实现是面向对象版本的，说明在这里，http://www.cppblog.com/mythit/archive/2009/04/21/80633.html，http://mindlee.net/2011/11/25/string-matching/，http://blog.csdn.net/shuangde800/article/details/8145591

历史评论

ZRJ (2013-11-20 21:10:42):

注意到上面有一个 prefix 这个变量，实际上，是因为题目中，给出的关键词可能有重复的，而对于有重复的关键词，需要计数两次，所以才需要这个东西

std unique 的实现

Thu, 07 Nov 2013 10:15:19 +0800

接触到 std 的 unique 这个函数，看了一下实现，自己也写了一下。在读默认的实现的时候发现代码真是的比较坑爹的，缩进啊，花括号啊，之类的，都是不按规范来的。

自己照着写了一个如下

#include <iostream>
#include <vector>

template<class It>
It myUnique(It itBegin, It itEnd) {
    for (It itBegin2; (itBegin2 = itBegin) != itEnd && ++itBegin != itEnd; ) {
        if (*itBegin2 == *itBegin) {
            for (; ++itBegin != itEnd; ) {
                if (*itBegin2 != *itBegin) {
                    *++itBegin2 = *itBegin;
                }
            }
            return ++itBegin2;
        }
    }
    return itEnd;
}

template<class It>
void iteratorPrint(It itBegin, It itEnd) {
    while (itBegin != itEnd) {
        printf("%d\n", *itBegin++);
    }
}

int main() {
    std::vector<int> numbers;
    numbers.push_back(3);
    numbers.push_back(4);
    numbers.push_back(4);
    numbers.push_back(5);
    numbers.push_back(5);
    numbers.push_back(6);
    numbers.push_back(6);
    iteratorPrint(numbers.begin(), numbers.end());
    printf("--------------------\n");
    myUnique(numbers.begin(), numbers.end());
    iteratorPrint(numbers.begin(), numbers.end());
    return 0;
}

输出如下

3
4
4
5
5
6
6
--------------------
3
4
5
6
5
6
6

注意到代码的 8 到 12 行，这个地方，他只是判等，一旦不等，就把后面的覆盖到前面来，那么，就需要要求，原来的序列里面，相同的元素是相邻的，另外，他只是覆盖，并不删除后面的，那么就要求，调用完这个函数之后，还要自己去把后面的也给删除了。

找出第一个不重复的字母

Mon, 24 Sep 2012 20:01:01 +0800

今天笔试，遇到一个题目要找出一个字符串中第一个不重复的字母，简单写了一下

#include <stdio.h>

void find(const char *str, char *result)
{
	int count[128]={0}, pos[128]={0};
	for (int i=0; str[i]!='\0'; i++)
	{
		int ascii = (int)(str[i]);
		count[ascii]++;
		if (pos[ascii] == 0)
		{
			pos[ascii] = i;
		}
	}
	int min = 99999;
	for (int i=0; i<128; i++)
	{
		if (count[i] == 1 && pos[i]<min)
		{
			*result = (char)i;
			min = pos[i];
		}
	}
}

int main()
{
	char *str = "teeter";
	char result;
	find(str, &result);
	printf("%cn", result);
	return 0;
}

蛇形填数

Sat, 22 Sep 2012 15:45:33 +0800

之前因为家里的原因，回乡下一个星期，期间都没有机会，也没有心情写代码，一个星期就这么毫无长进，罪过。

看到一个蛇形填数的题目，搞了搞，代码如下

#include <stdio.h>
#include <stdlib.h>

void print(int **a, int n)
{
	for (int y=0; y<n; y++)
	{
		for (int x=0; x<n; x++)
		{
			printf("%dt", a[x][y]);
		}
		printf("n");
	}
	printf("n");
}

void clear(int **a, int n)
{
	for (int y=0; y<n; y++)
	{
		for (int x=0; x<n; x++)
		{
			a[x][y] = 0;
		}
	}
}

void fill(int **a, int n)
{
	int xx[4] = {1, 0, -1, 0};
	int yy[4] = {0, 1, 0, -1};
	int x=0, y=0, pos=0;
	for (int i=1; i<=n*n; i++)
	{
		a[x][y] = i;
		if (x+xx[pos]>=n || x+xx[pos]<0
			|| y+yy[pos]>=n || y+yy[pos]<0
			|| a[x+xx[pos]][y+yy[pos]]!=0)
		{
			pos = (pos+1) % 4;
		}
		x += xx[pos];
		y += yy[pos];
	}
}

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{

		int **a = (int **)malloc(sizeof(int *) * n);
		for (int i=0; i<n; i++)
		{
			a[i] = (int *)malloc(sizeof(int) * n);
		}
		clear(a, n);
		fill(a, n);
		print(a, n);
		for (int i=0; i<n; i++)
		{
			free(a[i]);
		}
		free(a);
	}
	return 0;
}

输入输出

2
1       2
4       3

5
1       2       3       4       5
16      17      18      19      6
15      24      25      20      7
14      23      22      21      8
13      12      11      10      9

生成可重集的排列

Fri, 14 Sep 2012 16:41:26 +0800

刘汝佳在算法竞赛入门经典，http://book.douban.com/subject/4138920/，的 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列很相像，但是写法却巧妙很多

#include <stdio.h>

void quick_sort(int a[], int left, int right)
{
	int i=left, j=right;
	int povit = a[(i+j)/2];
	while (i <= j)
	{
		while (a[i] < povit)
		{
			i++;
		}
		while (a[j] > povit)
		{
			j--;
		}
		if (i <= j)
		{
			int tmp = a[j];
			a[j] = a[i];
			a[i] = tmp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(a, left, j);
	}
	if (i < right)
	{
		quick_sort(a, i, right);
	}
}

void print_permutation(int n, int *p, int *a, int cur)
{
	int i, j;
	if (cur == n)
	{
		for (i=0; i<n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("n");
	}
	else
	{
		for (i=0; i<n; i++)
		{
			if (!i || p[i]!=p[i-1])
			{
				int c1=0, c2=0;
				for (j=0; j<cur; j++)
				{
					if (a[j] == p[i])
					{
						c1++;
					}
				}
				for (j=0; j<n; j++)
				{
					if (p[i] == p[j])
					{
						c2++;
					}
				}
				if (c1 < c2)
				{
					a[cur] = p[i];
					print_permutation(n, p, a, cur+1);
				}
			}
		}
	}
}

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		int *p = new int[n];
		for (int i=0; i<n; i++)
		{
			scanf("%d", &p[i]);
		}
		quick_sort(p, 0, n-1);
		int *a = new int[n];
		print_permutation(n, p, a, 0);
		delete[] p;
		delete[] a;
	}
	return 0;
}

输入输出

需要说明的是，他的这种全排列生成需要数组有序，于是顺便就当作复习了一遍快排了

简单枚举的除法

Fri, 14 Sep 2012 15:16:13 +0800

今天看到一个简单枚举的题目

除法输入正整数n，按从小到大的顺序输出所有形如abcde/fghij=n的表达式，其中a~~j恰好为数字0~~9的一个排列，2<=n<=79. 样例输入： 62 样例输出： 79546/01238=62 94736/01528=62

我是这么搞的

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int n;

void enumerate(char dividend[], int div_index)
{
	if (div_index == 5)
	{
		int divide = atoi(dividend);
		int product = divide * n;
		if (product > 10000 && product <99999)
		{
			char product_str[6];
			sprintf(product_str, "%d", product);
			int map[10] = {0};
			int conflict = 0;
			for (int i=0; i<5; i++)
			{
				if (map[product_str[i]-'0'] == 0)
				{
					map[product_str[i]-'0']++;
				}
				else
				{
					conflict = 1;
					break;
				}
			}
			for (int i=0; i<5; i++)
			{
				if (map[dividend[i]-'0'] == 0)
				{
					map[dividend[i]-'0']++;
				}
				else
				{
					conflict = 1;
					break;
				}
			}
			if ( ! conflict)
			{
				printf("%s / %s = %dn", product_str, dividend, n);
			}
		}
		return;
	}
	for (char ch='0'; ch<='9'; ch++)
	{
		int occupy = 0;
		for (int i=0; i<div_index; i++)
		{
			if (dividend[i] == ch)
			{
				occupy = 1;
				break;
			}
		}
		if ( ! occupy)
		{
			dividend[div_index] = ch;
			enumerate(dividend, div_index+1);
		}
	}
}

int main()
{
	while (scanf("%d", &n) == 1)
	{
		char dividend[6] = {0};
		enumerate(dividend, 0);
	}
	return 0;
}

输入输出

62
79546 / 01283 = 62
94736 / 01528 = 62
7
16758 / 02394 = 7
18459 / 02637 = 7
31689 / 04527 = 7
36918 / 05274 = 7
37926 / 05418 = 7
41832 / 05976 = 7
53298 / 07614 = 7
98532 / 14076 = 7

不过这明显太长了，继续写短。。

参考这里，http://blog.csdn.net/xujinsmile/article/details/7592875，得到如下代码

#include <stdio.h>

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		for (int i=1234; i<=98765; i++)
		{
			if (n*i <= 98765)
			{
				int map[10] = {0};
				int ii=i, ni=n*i;
				for (int j=0; j<5; j++, ii/=10, ni/=10)
				{
					map[ii%10]++;
					map[ni%10]++;
				}
				for (int j=0; j<10; j++)
				{
					if (map[j] != 1)
					{
						break;
					}
					if (j == 9)
					{
						if (i < 10000)
						{
							printf("%d / 0%d = %dn", n*i, i, n);
						}
						else
						{
							printf("%d / %d = %dn", n*i, i, n);
						}
					}
				}
			}
		}
	}
	return 0;
}

输入输出

62
79546 / 01283 = 62
94736 / 01528 = 62
7
16758 / 02394 = 7
18459 / 02637 = 7
31689 / 04527 = 7
36918 / 05274 = 7
37926 / 05418 = 7
41832 / 05976 = 7
53298 / 07614 = 7
98532 / 14076 = 7

栈结构练习

Fri, 14 Sep 2012 11:12:03 +0800

今天从刘汝佳的书上看到一个简单的栈的题目

有n节车厢从A方向驶入车站，按进站顺序编号1～n。现让这些火车按照某种特定的顺序进入B方向的铁轨并驶出车站。为了重组车厢，可以借助中转站C。C是一个可以停放任意多节车厢的车站，但由于末端封顶，驶入C的车厢必须按照相反的顺序驶出C。对于每个车厢，一旦从A移入C，就不能再回到A了；一旦从C移入B，就不能回到C了请编程判断判断：按给定的出站顺序，火车能否出站

用 c++ 的 stl 写的话是这样

#include <cstdio>
#include <stack>

using namespace std;

int main()
{
	int n;
	while (scanf("%d", &n) == 1)
	{
		int *target = new int[n+1];
		for (int i=1; i<=n; i++)
		{
			scanf("%d", &target[i]);
		}
		stack<int> s;
		int a=1, b=1, ok=1;
		while (b < n)
		{
			if (a == target[b])
			{
				a++;
				b++;
			}
			else if ( !s.empty() && s.top()==target[b])
			{
				s.pop();
				b++;
			}
			else if (a < n)
			{
				s.push(a);
				a++;
			}
			else
			{
				ok = 0;
				break;
			}
		}
		delete[] target;
		target = NULL;
		if (ok)
		{
			printf("Yesn");
		}
		else
		{
			printf("Non");
		}
	}
	return 0;
}

输入输出

5
1 2 3 4 5
Yes
5
5 4 1 2 3
No
6
6 5 4 3 2 1
Yes

输出一个字符串的组合

Thu, 13 Sep 2012 18:36:10 +0800

跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归

#include <stdio.h>
#include <string.h>

void combine(char str[], int str_index, char res_total, char result[], int res_index)
{
	if (res_total == res_index)
	{
		for (int i=0; i<res_total; i++)
		{
			printf("%c ", result[i]);
		}
		printf("n");
	}
	else if (str_index==strlen(str))
	{
		return;
	}
	else
	{
		result[res_index] = str[str_index];
		combine(str, str_index+1, res_total, result, res_index+1);
		combine(str, str_index+1, res_total, result, res_index);
	}
}

int main()
{
	char str[100];
	char result[100];
	scanf("%s", str);
	for (int i = 1; i<=strlen(str); i++)
	{
		combine(str, 0, i, result, 0);
	}
	return 0;
}

输入输出

abcd
a
b
c
d
a b
a c
a d
b c
b d
c d
a b c
a b d
a c d
b c d
a b c d

可以发现没有考虑去重的情况，这个应该比较容易，就是预处理扫一遍，如果是 ascii 字符的话，那么把输入的 str 映射要一个位图上就可以了。

KMP 串匹配

Thu, 13 Sep 2012 16:55:51 +0800

昨天一天没有写出代码来，惭愧惭愧，昨天在看红黑树和堆排序，可惜最后都没有能写出东西来，渐渐的感觉网络上的中文资料不太可以依赖了啊，要么就是没有，要么就是 google 出来排名在前面的都会写错，看来要么转向英文资料，要么转向纸质书了

今天参考这里，http://blog.csdn.net/v_july_v/article/details/7041827，写了个 KMP 串匹配，感觉 KMP 也是网络上的中文资料好多错的，而且讲的也繁杂，看了好久都没有能够讲清楚

#include <iostream>
#include <string>

using namespace std;

int kmp(const string &target, const string &pattern)
{
	const int tar_len = target.size();
	const int pat_len = pattern.size();

	// 构造 next 数组
	int *next = new int[pat_len];
	next[0] = -1;
	int index = 0;
	for (int i=1; i<pat_len; i++)
	{
		index = next[i-1];
		while (index>=0 && pattern[index+1]!=pattern[i])
		{
			index = next[index];
		}
		if (pattern[index+1] == pattern[i])
		{
			next[i] = index + 1;
		}
		else
		{
			next[i] = -1;
		}
	}

	// KMP 匹配
	int par_index = 0;
	int tar_index = 0;
	while (par_index<pat_len && tar_index<tar_len)
	{
		if (target[tar_index] == pattern[par_index])
		{
			tar_index++;
			par_index++;
		}
		else if (par_index == 0)
		{
			tar_index++;
		}
		else
		{
			par_index = next[par_index-1] + 1;
		}
	}

	delete[] next;

	if(par_index == pat_len)
	{
		return tar_index-par_index;
	}
	else
	{
		return -1;
	}
}

int main()
{
	string target = "ababc";
	string pattern = "abc";
	cout<<kmp(target, pattern)<<endl;
	return 0;
}

输入输出

算法复习之归并排序

Fri, 07 Sep 2012 18:03:29 +0800

今天接到电话面试的时候提到了一个归并排序，之前用的比较少，于是完了之后参照 http://blog.csdn.net/morewindows/article/details/6678165 写了一个归并排序

#include <stdio.h>
#include <stdlib.h>

void merge(int n[], int first, int mid, int last, int temp[])
{
	int i=first, j=mid+1, k=0;
	while (i<=mid && j<=last)
	{
		if (n[i] < n[j])
		{
			temp[k++] = n[i++];
		}
		else
		{
			temp[k++] = n[j++];
		}
	}
	while (i <= mid)
	{
		temp[k++] = n[i++];
	}
	while (j <= last)
	{
		temp[k++] = n[j++];
	}
	for (i=0; i<k; i++)
	{
		n[first+i] = temp[i];
	}
}

void m_sort(int n[], int first, int last, int temp[])
{
	if (first < last)
	{
		int mid = (first + last) / 2;
		m_sort(n, first, mid, temp);
		m_sort(n, mid+1, last, temp);
		merge(n, first, mid, last, temp);
	}
}

int main()
{
	int k;
	scanf("%d", &k);
	int *n = (int *)malloc(k*sizeof(int));
	int *temp = (int *)malloc(k*sizeof(int));
	if (!n || !temp)
	{
		exit(1);
	}
	int i;
	for (i=0; i<k; i++)
	{
		scanf("%d", &n[i]);
	}
	m_sort(n, 0, k-1, temp);
	for (i=0; i<k; i++)
	{
		printf("%d ", n[i]);
	}
	printf("n");
	free(n);
	free(temp);
}

输入输出：

5
3 1 2 4 0
0 1 2 3 4

归并排序的时间复杂度是 O(n*log(n))，数据是稳定的

输出一个字符串的全排列

Thu, 06 Sep 2012 20:44:02 +0800

今天看到 http://blog.csdn.net/morewindows/article/details/7370155 这里提出了一个问题

用C++写一个函数, 如 Foo(const char *str), 打印出 str 的全排列, 如 abc 的全排列: abc, acb, bca, dac, cab, cba

想了想（想了好久啊，好久没有碰数据结构和算法了），觉得可以 dfs，这样来搞：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000

char str[MAX];
int len;
char tmp[MAX];
char used[MAX];

void arrange(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i = 0;
	for (i=0; i<len; i++)
	{
		if ( ! used[i])
		{
			used[i] = 1;
			tmp[pos] = str[i];
			arrange(pos+1);
			used[i] = 0;
		}
	}
}

int main()
{
	scanf("%s", str);
	len = strlen(str);
	memset(used, 0, sizeof(used));
	memset(tmp, 0, sizeof(tmp));
	arrange(0);
	return 0;
}

结果如下：

但是问题是如果过滤掉重复的呢，最简单的一个想法是，用 stl 搞个 set，找到的结果先不打印出来，统统往 set 里面装，让 set 天然的帮我们过滤，最后用一个循环输出出来，但是，如果自己实现呢，回头看我们之前的代码，我们可以发现，在 dfs 的时候，字符在串中位置是有影响的，也就是说，对于上面的程序来说，abca 和 abac 是不一样的，但是，我们却希望，字符在串中的位置是无关紧要的，自然就想到，如果我们把相同的字符归成一群，这样就能解决问题，也就是说，我们需要把刚刚那两个串预处理一下，把他们都变成，一坨 a，然后一个 b，然后一个 c，于是得到下面的代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000

typedef struct _letter {
	char ch;
	int count;
} letter;

letter letters[MAX];
int letters_arr_size = 0;

char input[MAX];
int len;
char tmp[MAX];

void preprocess();
void dfs(int pos);

int main()
{
	scanf("%s", input);
	len = strlen(input);
	preprocess();
	dfs(0);
	return 0;
}

void preprocess()
{
	memset(letters, 0, sizeof(letters));
	int i, j, found=0;
	for (i=0; i<len; i++)
	{
		found = 0;
		for (j=0; j<letters_arr_size; j++)
		{
			if (input[i] == letters[j].ch)
			{
				letters[j].count++;
				found = 1;
				break;
			}
		}
		if ( ! found)
		{
			letters[letters_arr_size].ch = input[i];
			letters[letters_arr_size].count = 1;
			letters_arr_size++;
		}
	}
}

void dfs(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i;
	for (i=0; i<letters_arr_size; i++)
	{
		if (letters[i].count > 0)
		{
			letters[i].count--;
			tmp[pos] = letters[i].ch;
			dfs(pos+1);
			letters[i].count++;
		}
	}
}

结果如下

但是至于怎么把这段递归等价的改写成循环，想了很是有一会儿，可惜暂时没有想出来

历史评论

输出一个字符串的组合 | ZRJ (2012-09-13 18:36:14):

[…] 跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归 […]

生成可重集的排列 | ZRJ (2012-09-14 16:41:32):

[…] 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列 […]

算法复习之快速排序

Fri, 10 Aug 2012 17:27:37 +0800

快速排序这个自己想了一会，真的想不出来，还是查了资料，使用 C89 标准函数库有一个非常简单的写法，（维基上的不能跑，自己稍稍改了一下）

#include <stdio.h>
#include <stdlib.h>

static int cmp(int *a, int *b)
{
	return *a-*b;
}

int main()
{
	int arr[10]={5, 3, 7, 4, 1, 9, 8, 6, 2};

	qsort(arr, 10, sizeof(int), (int(*) (const void *,const void *))cmp);

	return 0;
}

而我交到 hdu 的是

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
//	printf("pivot is %dn", pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
		//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
		//		i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		quick_sort(arr, 0, n-1);
		print(arr, n);
	}
	return 0;
}

最后，附上一个 python 的版本，再次体会到 python 的简洁

def qsort(L):
   if not L: return []
   return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] + 
          qsort([x for x in L[1:] if x>=L[0]])

不仅简洁，而且思路非常清晰，易懂，不过 python 这个版本空间复杂度比较高就是了

==============================================================

2012-08-11 00:37:12 update: 上面那个快排，有两个地方想不懂：

在 31 行 while 循环那里，为什么需要小于等于呢，为什么不能去掉等号呢
在 52 和 56 行那里，为什么需要判断 if 呢，那个地方是一个递归终止条件这我知道，问题是，那个 if 在什么情况下会不成立呢，i 从左往右递增，怎么会超过 right 呢，同理 j 也一样啊

==============================================================

2012-08-11 01:01:26 update: 第二个问题看下面这个代码的输出应该就能有体会了，具体我也不知道怎么说

#include <stdio.h>
#define MAX 1005

int total;
int *p_arr;

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	n = total;
	arr = p_arr;
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void quick_sort(int arr[], int left, int right)
{
	int i = left, j = right;
	int pivot = arr[(i+j)/2];
	printf("left is %d right is %d pivot is %dn", left, right, pivot);
	while (i <= j)
	{
		while (arr[i] < pivot)
		{
			i++;
		}
		while (arr[j] > pivot)
		{
			j--;
		}
		if (i <= j)
		{
			printf("swapping arr[%d]:%d and arr[%d]:%dn",
				i, arr[i], j, arr[j]);
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
			i++;
			j--;
			print(arr, 0);
		}
	}
	if (left < j)
	{
		quick_sort(arr, left, j);
	}
	else
	{
		printf("left is %d and not smaller than j is %dn", left, j);
	}
	if (i < right)
	{
		quick_sort(arr, i, right);
	}
	else
	{
		printf("i is %d and not smaller than right is %dn", i, right);
	}
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		p_arr = arr;
		int n = get(arr);
		total = n;
		quick_sort(arr, 0, n-1);
		print(arr, n);
		printf("donen");
	}
	return 0;
}

至于第一个问题嘛，我把等于号删掉了，交到 hdu 上是可以过的，看起来应该是没问题的，但是怎么证明呢

算法复习之冒泡排序与选择排序

Fri, 10 Aug 2012 13:23:29 +0800

基础丢的差不多了，是时候该重新捡起来，不然真的心虚啊，于是就从排序开始，上 poj 找基础的排序题居然没有，悲催，太低级了，最后在 hdu 上找到一个排序题，http://acm.hdu.edu.cn/showproblem.php?pid=1040

忘得差不多也有一个好处，就是可以自己从头再想，这次决定不看任何参考资料，就凭着模糊的印象，慢慢的把算法的思路先理清楚，然后动手写，再手工调，一点点来，这样才能更好的理解，悲催的是，一个冒泡排就搞了一个上午啊

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void sort(int arr[], int n)
{
	int i, j;
	for (i=0; i<n-1; i++)
	{
	//	printf("processing arr[%d]:%dn", i, arr[i]);
		for (j=0; j<n-i-1; j++)
		{
		//	printf("checking for arr[%d]:%d and arr[%d]:%dn",
		//		j, arr[j], j+1, arr[j+1]);
			if (arr[j] > arr[j+1])
			{
			//	printf("swapping arr[%d]:%d and arr[%d]:%dn",
			//		j, arr[j], j+1, arr[j+1]);
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			//	print(arr, n);
			}
		}
	}
//	printf("donen");
	return;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		sort(arr, n);
		print(arr, n);
	}
	return 0;
}

遇到的问题在于，看高亮的第 32 行，如果把 for 循环的初始条件从 j=0 改成 j=i 就 WA 了，这是为什么呢，有兴趣的可以自己想想

冒泡排序出来了，选择也跟着很快就出来了

#include <stdio.h>
#define MAX 1005

int get(int arr[])
{
	int n, i;
	scanf("%d", &n);
	for (i=0; i<n; i++)
	{
		scanf("%d", &arr[i]);
	}
	return n;
}

void print(int arr[], int n)
{
	printf("%d", arr[0]);
	int i;
	for (i=1; i<n; i++)
	{
		printf(" %d", arr[i]);
	}
	printf("n");
}

void sort(int arr[], int n)
{
	int i, j;
	for (i=0; i<n-1; i++)
	{
		int min = i;
		for (j=i+1; j<n; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			int temp = arr[i];
			arr[i] = arr[min];
			arr[min] = temp;
		}
	}
	return;
}

int main()
{
	int t;
	scanf("%d", &t);
	while (t--)
	{
		int arr[MAX] = {0};
		int n = get(arr);
		sort(arr, n);
		print(arr, n);
	}
	return 0;
}

选择排序是我觉得最自然，最好理解的排序方法，我记得当时大一的时候，刚接触 C ，什么都没学，自己琢磨出来的就是选择，倒是冒泡还费劲理解。。