C++博客-糯米-随笔分类-Algorithm

str_fastcmp

糯米 — Wed, 14 Sep 2011 14:00:00 GMT

摘自：luajit源码lj_str.c

/* Fast string data comparison. Caveat: unaligned access to 1st string! */
static LJ_AINLINE int str_fastcmp(const char *a, const char *b, MSize len)
{
  MSize i = 0;
  lua_assert(len > 0);
  lua_assert((((uintptr_t)a + len) & (LJ_PAGESIZE-1)) <= LJ_PAGESIZE-4);
  do {  /* Note: innocuous access up to end of string + 3. */
    uint32_t v = lj_getu32(a+i) ^ *(const uint32_t *)(b+i);
    if (v) {
      i -= len;
#if LJ_LE
      return (int32_t)i >= -3 ? (v << (32+(i<<3))) : 1;
#else
      return (int32_t)i >= -3 ? (v >> (32+(i<<3))) : 1;
#endif
    }
    i += 4;
  } while (i < len);
  return 0;
}

糯米 2011-09-14 22:00 发表评论

Minimal Steiner Tree 简介

糯米 — Wed, 23 Feb 2011 16:19:00 GMT

MinimalSteinerTree 的意思是：
在图中找出一个生成树，需要将指定的数个点连接，边权总值最小。
最小生成树是 MinimalSteinerTree 的一种特殊情况。
此问题是NP完全问题。
在POJ 3123中的标程给出了一个递归的算法来解决这个问题。

首先用floyd算法求出两两之间的最短路径。
然后把所有点都两两链接起来，权值就是它们的最短路径。
假设指定必须连接的点有N个。
那么MinimalSteinerTree 树中的内点最多有N-2个。
在纸上画一下就知道了，内点最多的情况就是树为满二叉树的情况。
而由于之前的floyd算法。把整个图给“缩”了一下。
所以树最多有N-2+N个点。
枚举所有可能的点集。对每个点集求最小生成树。取最小值即可。

另外一种方法是使用动态规划，详情请见这里。

糯米 2011-02-24 00:19 发表评论

[小程序]给出一个圆，上面有数个点，任取4个点组成四边形，使得此四边形面积最大

糯米 — Sat, 15 Jan 2011 03:07:00 GMT

这个问题源于POJ 2500。由于看错了题目，我把题意理解成“给出一个圆，上面有数个点，任取4个点组成四边形，使得此四边形面积最大”。
标程给出的方法是O(N^2)，是对于点之间距离固定的情况。
我也想出了一个O(N^2)的算法用于解决任意位置的点的情况。

将点按照顺时针排序
假设四边形的四个点A, B, C, D。按照顺时针方向排序。
按顺序枚举A
按顺序枚举C
B取最接近弧AC中心的点，D同理

在纸上画画就可以看出，如果C是递增的，则BD也是递增的。
因此C扫了一圈，BD加起来最多也扫两圈。
枚举A是O(N)，枚举C是O(N)，BD均摊下来也是O(N)
所以总复杂度是O(N^2)

虽然说复杂度跟标程一样，但还是TLE了，哥很久没写C代码了，现在比较挫。

糯米 2011-01-15 11:07 发表评论

[转] Floyd 算法原理

糯米 — Sat, 15 Jan 2011 02:56:00 GMT

floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在），floyd算法加入了这个概念

A^k(i,j)：表示从i到j中途不经过索引比k大的点的最短路径。

这个限制的重要之处在于，它将最短路径的概念做了限制，使得该限制有机会满足迭代关系，这个迭代关系就在于研究：假设A^k(i,j)已知，是否可以借此推导出A^k-1(i,j)。

假设我现在要得到A^k(i,j)，而此时A^k(i,j)已知，那么我可以分两种情况来看待问题：1. A^k(i,j)沿途经过点k；2. A^k(i,j)不经过点k。如果经过点k，那么很显然，A^k(i,j) = A^k-1(i,k) + A^k-1(k,j)，为什么是A^k-1呢？因为对(i,k)和(k,j)，由于k本身就是源点（或者说终点），加上我们求的是A^k(i,j)，所以满足不经过比k大的点的条件限制，且已经不会经过点k，故得出了A^k-1这个值。那么遇到第二种情况，A^k(i,j)不经过点k时，由于没有经过点k，所以根据概念，可以得出A^k(i,j)=A^k-1(i,j)。现在，我们确信有且只有这两种情况---不是经过点k，就是不经过点k，没有第三种情况了，条件很完整，那么是选择哪一个呢？很简单，求的是最短路径，当然是哪个最短，求取哪个，故得出式子：

A^k(i,j) = min( A^k-1(i,j), A^k-1(i,k) + A^k-1(k,j) )

因此floyd的最外层循环：
for (k = 0; k < n; k++) ...
就是分别求出 A0(i,j), A1(i,j), ..., An(i,j)
我屡次写错floyd的程序，今天又写错一次。。尽管它很短，但原理真的很牛比。
只要知道了原理，就不会再写错了！

糯米 2011-01-15 10:56 发表评论

小程序：消除方块游戏

糯米 — Tue, 23 Nov 2010 08:32:00 GMT

有一个这样的小游戏：

多个不同颜色的方块位于一列，你每次可以消除一片连续的相同颜色的方块，并获得得分｛连续方块的个数^2｝。
消除完后右边的方块移动过来。
问，怎样玩才能使得分最高？

这是一道黑书上面的题目。我想了n久想不出来。。
黑书的解法是动态规划，时间复杂度为O(N^4)，空间复杂度为O(N^3)。
觉得挺有意思的，就把它的方法实现了一下。

# Block Game

blocks = [(1,2), (2,4), (3,5), (1,2), (3,6), (1,9), (2,10)]
best = {}
choose = {}

def sqr(x):
    return x*x

def dfs(i, j, k):
    if j < i:
        return 0
    if (i, j, k) in best:
        return best[(i, j, k)]
    m = [(sqr(k + blocks[j][1]) + dfs(i, j - 1, 0), j)]
    for p in range(i, j):
        if blocks[p][0] == blocks[j][0]:
            m += [(dfs(i, p, k + blocks[j][1]) + dfs(p + 1, j - 1, 0), p)]
    best[(i, j, k)], choose[(i, j, k)] = max(m)
    return best[(i, j, k)]

def show(i, j, k, s):
    if j < i:
        return
    #print 'show', i, j, k, blocks
    c = choose[(i, j, k)]
    if c == j:
        s += sqr(blocks[c][1])
        print blocks, 'remove', c, ':', blocks[c], 'score', s
        del blocks[c]
        show(i, j - 1, 0, s)
    else:
        show(c + 1, j - 1, 0, s)
        v = blocks[c + 1][1]
        blocks[c] = (blocks[c][0], blocks[c][1] + v)
        del blocks[c + 1]
        show(i, c, v, s)

dfs(0, len(blocks) - 1, 0)
show(0, len(blocks) - 1, 0, 0)

糯米 2010-11-23 16:32 发表评论

小程序：给出n个数，如何找出三个数，它们的和等于k

糯米 — Sun, 21 Nov 2010 15:10:00 GMT

通常的思路是O(N^3)
但可以有小小优化：
一。先排序
二。枚举i, j, k的时候，固定i的时候，j和k分别从左从右扫描数组，直到两个碰到为止。
三。对于每个i，k从右扫描的开始位置是递减的。

然后就有了下面的小程序：

#include <stdio.h>
#include <iostream>
#include <algorithm>

using namespace std;

int N = 10;
int K = 5;
int arr[] = {1, 2, 5, 4, 5, 10, 2, 3, 5, 1};

int main()
{
    int a, b, c, i;

    sort(arr, arr + N);
    c = N - 1;
    for (a = 0; a < c; a++) {
        for (b = a + 1; b < c; b++) {
            while (c >= 0 && arr[a] + arr[b] + arr[c] > K)
                c--;
            for (i = c; b < i; b++) {
                while (i >= 0 && arr[a] + arr[b] + arr[i] > K)
                    i--;
                if (i >= 0 && arr[a] + arr[b] + arr[i] == K)
                    printf("%d %d %d\n", arr[a], arr[b], arr[i]);
            }
        }
    }

    return 0;
}

糯米 2010-11-21 23:10 发表评论

Dinic 算法模板

糯米 — Thu, 12 Aug 2010 06:33:00 GMT

Dinic算法是一种比较容易实现的，相对比较快的最大流算法。
今天看了一下它的原理，发现的确很牛逼。

求最大流的本质，就是不停的寻找增广路径。直到找不到增广路径为止。
对于这个一般性的过程，Dinic算法的优化如下：

（1）
Dinic算法首先对图进行一次BFS，然后在BFS生成的层次图中进行多次DFS。
层次图的意思就是，只有在BFS树中深度相差1的节点才是连接的。
这就切断了原有的图中的许多不必要的连接。很牛逼！
这是需要证明的，估计证明也很复杂。

（2）
除此之外，每次DFS完后，会找到路径中容量最小的一条边。
在这条边之前的路径的容量是大于等于这条边的容量的。
那么从这条边之前的点，可能引发出别的增广路径。
比如说 S -> b -> c -> d -> T 是一条增广路径，容量最小的边是 b -> c。
可能存在一条 S -> b -> e -> f -> g -> T 这样的增广路径。
这样的话，在找到第一条增广路径后，只需要回溯到 b 点，就可以继续找下去了。
这样做的好处是，避免了找到一条路径就从头开始寻找另外一条的开销。
也就是再次从 S 寻找到 b 的开销。
这个过程看似复杂，但是代码实现起来很优雅，因为它的本质就是回溯！

（3）
在同一次 DFS 中。如果从一个点引发不出任何的增广路径，就将这个点在层次图中抹去。

而这样一个算法，实现起来居然只需要100行。太吊了。
我的代码是参考别人的代码写的。可以用 POJ 1273 测试。

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

#define MAX_VETXS 1024
#define MAX_EDGES 1024

int E[MAX_EDGES], next[MAX_EDGES], C[MAX_EDGES], M;
int V[MAX_VETXS], L[MAX_VETXS], Q[MAX_VETXS], N;
int S, T;

void __insert(int from, int to, int cap)
{
    M++;
    C[M] = cap;
    E[M] = to;
    next[M] = V[from];
    V[from] = M;
}

void insert(int from, int to, int cap)
{
    __insert(from, to, cap);
    __insert(to, from, 0);
}

int bfs()
{
    int h, t, e, u, v;

    h = t = 0;
    Q[t++] = S;
    memset(L, 0, N*sizeof(L[0]));
    L[S] = 1;
    while (h != t) {
        u = Q[h++];
        for (e = V[u]; e; e = next[e]) {
            v = E[e];
            if (!L[v] && C[e] > 0) {
                L[v] = L[u] + 1;
                Q[t++] = v;
            }
        }
    }

    return L[T];
}

int dfs()
{
    int t, u, v, e, i, f, r, back;

    t = 1;
    r = 0;

    while (t) {
        u = (t == 1) ? S : E[Q[t - 1]];
        if (u == T) {
            f = INT_MAX;
            for (i = 1; i < t; i++) {
                e = Q[i];
                if (C[e] < f) {
                    f = C[e];
                    back = i;
                }
            }
            for (i = 1; i < t; i++) {
                e = Q[i];
                C[e] -= f;
                C[e^1] += f;
            }
            r += f;
            t = back;
        } else {
            for (e = V[u]; e; e = next[e]) {
                v = E[e];
                if (L[v] == L[u] + 1 && C[e] > 0)
                    break;
            }
            if (e)
                Q[t++] = e;
            else {
                t--;
                L[u] = 0;
            }
        }
    }

    return r;
}

int dinic()
{
    int f = 0;

    while (bfs())
        f += dfs();

    return f;
}

int main()
{
    int n, m, a, b, c, i;

    freopen("d:\\in.txt", "r", stdin);

    while (scanf("%d%d", &n, &m) != EOF) {
        S = 0;
        T = m - 1;
        N = m;
        memset(V, 0, N*sizeof(V[0]));
        M = 2;
        for (i = 0; i < n; i++) {
            scanf("%d%d%d", &a, &b, &c);
            insert(a - 1, b - 1, c);
        }
        printf("%d\n", dinic());
    }

    return 0;
}

糯米 2010-08-12 14:33 发表评论

KMP 演示程序

糯米 — Thu, 29 Apr 2010 04:48:00 GMT

下面这个小程序，可以演示 KMP 的匹配过程。
一直没有真正理解这个算法，昨天看了下算法导论。才懂了。
确实是一个相当精辟，相当巧妙的算法。太牛逼了！

#include
#include

#define MAX_LEN 256

int tbl[MAX_LEN];
char *str = "abbbbbbb";
char *ptn = "bb";
char spc[MAX_LEN];

int main()
{
    int i, j;

    memset(spc, ' ', sizeof(spc));

    tbl[0] = 0;
    for (i = 1; ptn[i]; i++) {
        for (j = tbl[i - 1]; j && ptn[j] != ptn[i]; j = tbl[j]);
        if (ptn[j] == ptn[i])
            j++;
        tbl[i] = j;
    }
    printf("table:\n");
    for (i = 0; ptn[i]; i++)
        printf("  %c", ptn[i]);
    printf("\n");
    for (i = 0; ptn[i]; i++)
        printf("%3d", tbl[i]);
    printf("\n");

    j = 0;
    for (i = 0; str[i]; ) {
        printf("\nmatching #%d\n", i);
        printf("%s\n", str);
        fwrite(spc, 1, i - j, stdout);
        printf("%s\n", ptn);
        fwrite(spc, 1, i, stdout);
        printf("^\n");

        if (str[i] == ptn[j]) {
            i++;
            j++;
            printf("ok\n");
        } else {
            if (j)
                j = tbl[j - 1];
            else
                i++;
            printf("jumped to %d\n", j);
        }
        if (!ptn[j])
            printf("matched at %d\n", i);
    }

    return 0;
}

输出：
table:
b b
0 1

matching #0
abbbbbbb
bb
^
jumped to 0

matching #1
abbbbbbb
bb
^
ok

matching #2
abbbbbbb
bb
^
ok
matched at 3

matching #3
abbbbbbb
bb
^
jumped to 1

matching #3
abbbbbbb
bb
^
ok
matched at 4

matching #4
abbbbbbb
bb
^
jumped to 1

matching #4
abbbbbbb
bb
^
ok
matched at 5

matching #5
abbbbbbb
bb
^
jumped to 1

matching #5
abbbbbbb
bb
^
ok
matched at 6

matching #6
abbbbbbb
bb
^
jumped to 1

matching #6
abbbbbbb
bb
^
ok
matched at 7

matching #7
abbbbbbb
bb
^
jumped to 1

matching #7
abbbbbbb
bb
^
ok
matched at 8

糯米 2010-04-29 12:48 发表评论

[转]LCA问题（含RMQ的ST算法）

糯米 — Wed, 10 Mar 2010 06:14:00 GMT

转自: http://www.cppblog.com/Icyflame/

一、定义与定理
      LCA：Least Common Ancestors（最近公共祖先），对于一棵有根树T的任意两个节点u，v，求出LCA(T, u, v)，即离跟最远的节点x，使得x同时是u和v的祖先。
      在线算法：用比较长的时间做预处理，但是等信息充足以后每次回答询问只需要用比较少的时间。
      离线算法：先把所有的询问读入，然后一起把所有询问回答完成。
      RMQ：给出一个数组A，回答询问RMQ(A, i, j)，即A[i...j]之间的最值的下标。
二、DFS+RMQ
      1）Sparse Table（ST）算法
      描述：

1 //初始化
2 INIT_RMQ
3 //max[i][j]中存的是重j开始的i个数据中的最大值，最小值类似，num中存有数组的值
4     for i : 1 to n
5         max[0][i] = num[i]
6     for i : 1 to log(n)/log(2)
7         for j : 1 to n
8             max[i][j] = MAX(max[i-1][j], max[i-1][j+2^(i-1)]
9 //查询
10 RMQ(i, j)
11     k = log(j-i+1) / log(2)
12     return MAX(max[k][i], max[k][j-2^k+1])

      分析：初始化过程实际上是一个动态规划的思想。易知，初始化过程效率是O(nlogn)，而查询过程效率是O(1)。ST是一个在线算法。
      示例：POJ 3368 解题报告
      2）求解LCA问题
      描述：
      （1）DFS：从树T的根开始，进行深度优先遍历，并记录下每次到达的顶点。第一个的结点是root(T)，每经过一条边都记录它的端点。由于每条边恰好经过2次，因此一共记录了2n-1个结点，用E[1, ... , 2n-1]来表示。
      （2）计算R：用R[i]表示E数组中第一个值为i的元素下标，即如果R[u] < R[v]时，DFS访问的顺序是E[R[u], R[u]+1, ..., R[v]]。虽然其中包含u的后代，但深度最小的还是u与v的公共祖先。
      （3）RMQ：当R[u] ≥ R[v]时，LCA[T, u, v] = RMQ(L, R[v], R[u])；否则LCA[T, u, v] = RMQ(L, R[u], R[v])，计算RMQ。
      由于RMQ中使用的ST算法是在线算法，所以这个算法也是在线算法。
      示例：ZOJ 3195 解题报告。
三、Tarjan算法
      描述：Tarjan算法是一个离线算法，也就是说只有先获得所有的查询，再按一个特定的顺序进行运算。

1 //parent为并查集，FIND为并查集的查找操作
2 Tarjan(u)
3     visit[u] = true
4     for each (u, v) in QUERY
5         if visit[v]
6             ans(u, v) = FIND(v)
7     for each (u, v) in TREE
8         if !visit[v]
9             Tarjan(v)
10             parent[v] = u

示例：HDOJ 2586 解题报告。

糯米 2010-03-10 14:14 发表评论