題目大意：

從n*n的矩陣中取出一些數使得這些數互不相鄰，問最大和為多少

大致思路：

明顯的狀態壓縮DP，每兩行之間的狀態轉移，這裡受到記憶體限制只開兩個陣列來表示當先行和下一行來進行轉移，原本想用vector來記錄那兩個狀態之間可以轉換的，但是受到記憶體限制還是用時間換空間了

程式碼如下：

Result  :  Accepted     Memory  :  8520 KB     Time  :  890 ms

/*
 * Author: Gatevin
 * Created Time:  2014/8/16 20:52:13
 * File Name: 123.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

int dp[1 << 20];
int nex[1 << 20];
vector <int> yes;
//vector <int> G[1 << 20];
int n;
int a[21][21];

bool check(int x)
{
    for(int i = 0; i <= (n - 2); i++)
    {
        if(((x >> i) & 1) == 1 && ((x >> (i + 1)) & 1) == 1)
        {
            return false;
        }
    }
    return true;
}

void init(int n)
{
    for(int i = 0; i <= ( 1 << n) - 1; i++)
    {
       if(check(i))
       {
          yes.push_back(i);
       }
    }
   return; 
}

int main()
{
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                scanf("%d", &a[i][j]);
            }
        }
        if(n == 1)
        {
            printf("%d\n", a[1][1]);
            continue;
        }
        memset(dp, 0, sizeof(dp));
        memset(nex, 0, sizeof(nex));
        yes.clear();
        init(n);
        for(unsigned int i = 0; i <= yes.size() - 1; i++)
        {
            for(int j = 0; j <= n - 1; j++)
            {
                if((1 << j) & yes[i])
                {
                    dp[yes[i]] += a[1][j + 1];
                    nex[yes[i]] += a[2][j + 1];
                }
            }
        }
        int dpnow = 1;
        /*for(int i = 0; i <= (1 << n) - 1; i++)
        {
            G[i].clear();
        }
        for(unsigned int i = 0; i <= yes.size() - 1; i++)
        {
            for(unsigned int j = i + 1; j <= yes.size() - 1; j++)
            {
                if((yes[i] & yes[j]) == 0)
                {
                    G[yes[i]].push_back(yes[j]);
                    G[yes[j]].push_back(yes[i]);
                }
            }
        }
        */
        while(dpnow < n)
        {
            /*for(unsigned int i = 0; i <= yes.size() - 1; i++)
            {
                int tmp = nex[yes[i]];
                for(unsigned int j = 0; j <= G[yes[i]].size() - 1; j++)
                {
                    nex[yes[i]] = max(nex[yes[i]], tmp + dp[G[yes[i]][j]]);
                }
            }
            */
            for(unsigned int i = 0; i <= yes.size() - 1; i++)
            {
                int tmp = nex[yes[i]];
                for(unsigned int j = 0; j <= yes.size() - 1; j++)
                {
                    if((yes[i] & yes[j]) == 0)
                    {
                        nex[yes[i]] = max(nex[yes[i]], tmp + dp[yes[j]]);
                    }
                }
            }
            for(unsigned int i = 0; i <= yes.size() - 1; i++)
            {
                dp[yes[i]] = nex[yes[i]];
            }
            dpnow++;
            if(dpnow == n) break;
            memset(nex, 0, sizeof(nex));
            for(unsigned int i = 0;i <= yes.size() - 1; i++)
            {
                for(int j = 0; j <= n - 1; j++)
                {
                    if(yes[i] & (1 << j))
                    {
                        nex[yes[i]] += a[dpnow + 1][j + 1];
                    }
                }
            }
        }
        int answer = 0;
        for(unsigned int i = 0; i <= yes.size() - 1; i++)
        {
            answer = max(answer, dp[yes[i]]);
        }
        printf("%d\n", answer);
    }   
    return 0;
}