codility上的练习 （1）
codility上面添加了教程。目前只有lesson 1，讲复杂度的……里面有几个题， 目前感觉题库的题简单。
tasks:
Frog-Jmp:
一只青蛙，要从X跳到Y或者大于等于Y的地方，每次跳的距离为D，问至少跳几次。 X,Y,D都是[1..10^9]的整数。
要求时间空间复杂度O(1)。
这个题比较简单，就是做除法嘛，我们不知道X是否已经不小于Y了，我加了个判断，不过也就一句话。
代码：
// you can also use includes, for example:
// #include <algorithm>
int solution(int X, int Y, int D) {
// write your code here...
return (X >= Y)?0:((Y - X + D - 1) / D);
}
Perm-Missing-Elem:
一个长度为N的数组里，都是整数，所有的数都不相同，范围是[1..N + 1]，这意味着有一个整数缺失了，找到这个缺失的整数，N的范围[0..10^5], 要求时间复杂度O(N)，空间复杂度O(1)。
分析：这个题是old题，我们至少有3种方法解决。
1 求和，注意使用long long。
// you can also use includes, for example:
// #include <algorithm>
int solution(vector<int> &A) {
// write your code here...
int n = A.size(), i, r = n + 1;
for (i = 0; i < n; ++i) {
r ^= (i + 1) ^ A[i];
}
return r;
}
2 求异或，不需要long long
// you can also use includes, for example:
// #include <algorithm>
int solution(vector<int> &A) {
// write your code here...
int n = A.size(), i, r = n + 1;
for (i = 0; i < n; ++i) {
r ^= (i + 1) ^ A[i];
}
return r;
}
3 把A[i]换到下标为A[i] - 1的位置，注意(N + 1)单独拿出来
// you can also use includes, for example:
// #include <algorithm>
int solution(vector<int> &A) {
// write your code here...
int n = A.size(),i,x,t;
for (i = 0; i < n; ++i) {
for (x = A[i]; (x <= n) && (A[x - 1] != x); ) {
t = A[x - 1];
A[x - 1] = x;
x = t;
}
}
for (i = 0; i < n; ++i) {
if (A[i] != i + 1) {
break;
}
}
return i + 1;
}
Tape-Equilibrium:
空数组长度为N，定义对0 < P < N, |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])|为P分割的两部分的差值，求最小的差值。 N在[2..10^5]，数组中数据范围[-1000,+1000]。要求复杂度时间O(N)，空间O(N)。
分析：这个题可以做到空间O(1)，我们主需要记录前P项和和总合就可以了。
// you can also use includes, for example:
// #include <algorithm>
int solution(vector<int> &A) {
// write your code here...
int n = A.size(), sum, r, i, t;
for (i = sum = 0; i < n; ++i) {
sum += A[i];
}
r = abs(sum - A[0] - A[0]);
for (i = 2, t = A[0]; i < n; ++i) {
t += A[i - 1];
r = min(r, abs(sum - t - t));
}
return r;
}
Further Training:
Abs-distinct:
一个长度为N的整数数组，已经按非降序排好序，求数组中的数有多少种不同的绝对值。数据范围N [1..10^5]，数组元素[-2147483648,+2147483647]。
要求复杂度 时间O(N)，空间O(N)。
分析：这个题可以做到空间复杂度O(1)，因为数组是排好序的，我们可以两头扫。但是由于数据范围-2147483648,我们不能随便取绝对值，因为会整数越界，这里要小心谨慎，不然过不了某一组数据。
// you can also use includes, for example:
// #include <algorithm>
int solution(const vector<int> &A) {
// write your code here...
int n = A.size(), i, j ,r, t;
for (i = r = 0, j = n - 1; (i < j) && (A[i] < 0) && (A[j] > 0); ++r) {
t = (A[i] + A[j] < 0)?A[i]:A[j];
for (;((t < 0) && (A[i] == t)) || ((t > 0) && (A[i] + t == 0)) ; ++i);
for (;((t < 0) && (A[j] + t == 0)) || ((t > 0) && (A[j] == t)); --j);
}
for (;i <= j;++r) {
for (t = A[i]; (i <= j) && (A[i] == t); ++i)
;
}
return r;
}
Binary-gap:
一个整数的2进制表示中，两个1bit直接全部是0, 0的个数叫做一个binary-gap，给定Ｎ，求其最长binary-gap。（两个1之间最大的连续0的个数）。
N [1..2147483647]。要求复杂度时间O(logN)，空间O(1)。
分析：右移（防止越界），我们记录上一个1bit的位置就可以了。
// you can also use includes, for example:
// #include <algorithm>
int solution(int N) {
// write your code here...
int i,r, last;
for (i = r = 0, last = -1; N; N >>= 1,++i) {
if (N & 1) {
if (last >= 0) {
r = max(i - last - 1, r);
}
last = i;
}
}
return r;
}
Equi:
貌似跟第一篇codility上的问题是一样的，只是改版后放到这里来了。
http://blog.csdn.net/caopengcs/article/details/9323743
// you can also use includes, for example:
// #include
int solution(const vector<int> &A) {
// write your code here...
int n = A.size(),i;
long long sum = 0, left = 0;
for (i = 0; i < n; ++i) {
sum += A[i];
}
for (i = 0; i < n; ++i) {
if (left == sum - A[i] - left) {
return i;
}
left += A[i];
}
}
Dominator:
找众数，即数组中出现次数超过一半的数。数组长度N [0..10^6] (有0），每个数组元素，整数[-2147483648, +2147483647]。要求时间复杂度O(N)，空间复杂度O(1)。
返回的是众数的任意一个下标。没有众数返回-1。
分析： 经典算法，假设众数是x，扫一遍，相同的话加一次，不同的话减一次，次数变为负数就换掉x。最后还要检查一遍x是否真的为众数。
代码：
// you can also use includes, for example:
// #include <algorithm>
int solution(const vector<int> &A) {
// write your code here...
int r, i , t, n = A.size();
for (i = r = t = 0; i < n; ++i) {
if (A[i] == A[r]) {
++t;
}
else if (--t < 0) {
t = 1;
r = i;
}
}
for (i = n - 1, n >>= 1; i >= 0; --i) {
if ((A[i] == A[r]) && (--n < 0)) {
return r;
}
}
return -1;
}
Max-profit:
给定数组是股票价钱，要在早时买，晚些时候卖（可以是同一天），求最大收益。天数N [1..10^5],每天的价格[0..10^9]。要求复杂度时间O(N)，空间O(1)。
分析：这个题已经写入算法导论第三版了，可以转化为最大子段和。但是还有另外的方法，如果我们知道某天卖出，那么买入的时候一定是这些天最便宜的日子收益才能最大。
代码：
// you can also use includes, for example:
// #include <algorithm>
int solution(const vector<int> &A) {
// write your code here...
int n = A.size(), i, profit, cheapest;
for (i = profit = cheapest = 0; i < n; ++i) {
if (A[i] < A[cheapest]) {
cheapest = i;
}
profit = max(profit, A[i] - A[cheapest]);
}
return profit;
}
Tree-height:
二叉树的高度，节点数N [1..1000]，要求复杂度时间空间都是O(N)。
分析：就是dfs，至于空间的话，主要看堆栈是否要计算了……代码我就写了一句话。
// you can also use includes, for example:
// #include <algorithm>
int solution(tree * T) {
// write your code here...
return T?(max(solution(T->l),solution(T->r)) + 1):(-1);
}
Array-inversion-count:
就是求数组逆序数，超过10^9，返回-1。 要求时间复杂度O(NlogN)，空间复杂度O(N)，没给N的范围。
经典分治算法，跟归并排序一样。
代码：
// you can also use includes, for example:
// #include <algorithm>
vector<int> temp;
int help(vector<int> &A,int from,int to) {
int i,j,r,r1,r2,mid;
if (to - from <= 0) {
return 0;
}
mid = (from + to) >> 1;
r1 = help(A, from, mid);
if (r1 > 1000000000) {
return -1;
}
r2 = help(A, mid + 1, to);
if (r2 > 1000000000) {
return -1;
}
if ((r = r1 + r2) > 1000000000) {
return -1;
}
temp.clear();
for (i = from, j = mid + 1; (i <= mid) && (j <= to);) {
if (A[i] <= A[j]) {
temp.push_back(A[i++]);
}
else {
if ((r += mid - i + 1) > 1000000000) {
return -1;
}
temp.push_back(A[j++]);
}
}
for (;i <= mid;++i) {
temp.push_back(A[i]);
}
for (;j <= to; ++j) {
temp.push_back(A[j]);
}
for (i = from; i <= to; ++i) {
A[i] = temp[i - from];
}
return r;
}
int solution(const vector<int> &A) {
// write your code here...
vector<int> a = A;
return help(a, 0, a.size() - 1);
}