【Codeforces】【161Div2】

【题目来源】http://www.codeforces.com/contest/263

【A. Beautiful Matrix】

【解析】模拟即可。按照题目的意思，找到1所在的位置(x, y)，然后输出abs(x - 3) + abs(y - 3)。

#include <iostream>
#include <cmath>

using namespace std;

int X, Y;

int main()
{
    for (int i = 1; i <= 5; i ++)
        for (int j = 1, a; j <= 5; j ++)
            {
                cin >> a;
                if (a) X = i, Y = j;
            }
    cout << abs(3 - X) + abs(3 - Y) << endl;
    return 0;
}

 

【B. Squares】

【解析】贪心。每个正方形都是以(0,0)和(ai,ai)为顶点的，因此将输入的数据按照ai进行排序，输出(A[N - K + 1], 0)即是符合题意的坐标。

#include <iostream>
#include <algorithm>

using namespace std;

int N, K, A[51];

int main()
{
    cin >> N >> K;
    for (int i = 1; i <= N; i ++) cin >> A[i];
    sort(A + 1, A + 1 + N);
    if (N - K < 0) cout << -1 << endl;
    else cout << A[N - K + 1] << " " << 0 << endl;
    return 0;
}

 

【C. Circle of Numbers】

【解析】枚举。根据题目的意思可得：对于每个点，有4个点与之相连；对于2个相邻的点，它们的公共点有2个。首先，通过枚举决定前3个数进入队列，接着，取出队列的末尾2个数，由这2个数决定的公共点必然有一个在队列中，另一个不在队列中，把不在队列中的数放进队列。接着重复以上过程，直到所有的数字都能够合法地进入队列，那么就说明找到了这样的环，否则不存在这样的环。另外，读入数据的时候，如果有某个数的度不为4，那么直接就可以判断不存在这样的环。

#include <cstdio>
#include <cstring>
#include <deque>

//#define FILE_IO

using namespace std;

const int Maxn = 100001;

struct edge
{
    int v;
    edge* next;
    edge(int _v, edge* _next) : v(_v), next(_next) {}
}* E[Maxn];

bool hash[Maxn];
int N, Cnt, Ans[Maxn], Deg[Maxn];
deque <int> Q;

void Print()
{
    for (int i = 1; i < N; i ++) printf("%d ", Ans[i]);
    printf("%d\n", Ans[N]);
}

int Find(int x, int y)
{
    for (edge* j = E[x]; j; j = j -> next)
        for (edge* k = E[y]; k; k = k -> next)
            if ((hash[j -> v] == false) && (j -> v == k -> v)) return j -> v;
    return 0;
}

bool Work(int x, int y)
{
    Q.clear(); Cnt = 0; memset(hash, 0, sizeof(hash));
    Q.push_back(x), Q.push_back(y);
    Ans[++ Cnt] = 1; Ans[++ Cnt] = x; Ans[++ Cnt] = y;
    hash[1] = hash[x] = hash[y] = true;
    while (Q.size())
    {
        int x = Q.front(); Q.pop_front();
        int y = Q.front(); Q.pop_front();
        int z = Find(x, y);
        if (z)
        {
            Q.push_back(y); Q.push_back(z); hash[z] = true;
            Ans[++ Cnt] = z;
        }
        else if (Cnt == N) return true;
    }
    return false;
}

bool Check(int x, int y)
{
    for (edge* j = E[x]; j; j = j -> next)
        if (j -> v == y) return true;
    return false;
}

bool Solve()
{
    int tmp[5], tcnt = 0;
    for (edge* j = E[1]; j; j = j -> next) tmp[++ tcnt] = j -> v;
    for (int i = 1; i <= 4; i ++)
        for (int j = 1; j <= 4; j ++)
        {
            if (i == j) continue;
            int x = tmp[i], y = tmp[j];
            if (!Check(x, y)) continue;
            if (Work(x, y)) return true;
        }
    return false;
}

void edgeAdd(int x, int y)
{
    E[x] = new edge(y, E[x]);
    E[y] = new edge(x, E[y]);
}

bool Init()
{
    scanf("%d", &N);
    for (int i = 1, x, y; i <= N * 2; i ++)
    {
        scanf("%d%d", &x, &y);
        Deg[x] ++; Deg[y] ++;
        edgeAdd(x, y);
    }
    for (int i = 1; i <= N; i ++)
        if (Deg[i] != 4) return false;
    return true;
}

int main()
{
    #ifdef FILE_IO
    freopen("test.in", "r", stdin);
    #endif // FILE_IO
    if ((!Init()) || (!Solve())) printf("-1\n");
    else Print();
    return 0;
}

【D. Cycle in Graph】

【解析】图论。从1个点进行DFS，当遇到未标记的点时候标记为已走。直到DFS到某个点，会发现所有和它相连的点都已经被标记上了。这说明了和它相连的这些点都已经存在于前面DFS的路径中了，由于这个点的度至少为K，也就是说，从已走路径中最早出现的和这个点相连的那个点开始，一直到当前的这个点结束，至少存在一个长度为K+1的圈。

#include <cstdio>
#include <climits>
#include <algorithm>

//#define FILE_IO

using namespace std;

const int Maxn = 1e5 + 1;

struct edge
{
    int v;
    edge* next;
    edge(int _v, edge* _next) : v(_v), next(_next) {}
}* E[Maxn];

int N, M, K, Cnt, S[Maxn], Visit[Maxn];

void Solve()
{
    S[Visit[1] = ++ Cnt] = 1;
    while (1)
    {
        int i = S[Cnt]; bool flag = false;
        for (edge* j = E[i]; j; j = j -> next)
        {
            int v = j -> v;
            if (!Visit[v])
            {
                S[Visit[v] = ++ Cnt] = v;
                flag = true;
                break;
            }
        }
        if (!flag)
        {
            int Min = INT_MAX;
            for (edge* j = E[i]; j; j = j -> next)
            {
                int v = j -> v; Min = min(Min, Visit[v]);
            }

            printf("%d\n", Cnt - Min + 1);
            for (int i = Min; i < Cnt; i ++) printf("%d ", S[i]);
            printf("%d\n", S[Cnt]);
            return ;
        }
    }
}

inline void edgeAdd(int x, int y)
{
    E[x] = new edge(y, E[x]);
    E[y] = new edge(x, E[y]);
}

void Init()
{
    scanf("%d%d%d", &N, &M, &K);
    for (int i = 1, x, y; i <= M; i ++)
    {
        scanf("%d%d", &x, &y);
        edgeAdd(x, y);
    }
}

int main()
{
    #ifdef FILE_IO
    freopen("test.in", "r", stdin);
    #endif // FILE_IO
    Init();
    Solve();
    return 0;
}

【E. Rhombus】

【解析】模拟。最没有想到的是这个题目，难度确实不大。模拟即可。不过同样需要处理一些技巧，具体看代码就OK。

#include <cstdio>

//#define FILE_IO

using namespace std;

int N, M, K, Ansx, Ansy;
long long Max, A[1001][1001], Sum[1001][1001];

void Print()
{
    printf("%d %d\n", Ansx, Ansy);
}

inline long long Count(int x1, int y1, int x2, int y2)
{
    return Sum[x2][y2] + Sum[x1 - 1][y1 - 1] - Sum[x2][y1 - 1] - Sum[x1 - 1][y2];
}

void Solve()
{
    int im = N - K + 1, jm = M - K + 1;
    for (int i = K; i <= im; ++i)
        for (int j = K; j <= jm; ++j)
        {
            long long tmp = 0;
            for (int k = 1; k <= K; ++k)
                tmp += Count(i - K + k, j - k + 1, i + K - k, j + k - 1);
            if (tmp >= Max) Max = tmp, Ansx = i, Ansy = j;
        }
}

void Init()
{
    scanf("%d%d%d", &N, &M, &K);
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= M; ++j)
            scanf("%d", &A[i][j]);
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= M; ++j)
            A[i][j] += A[i - 1][j];
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= M; ++j)
            Sum[i][j] = Sum[i][j - 1] + A[i][j];
}

int main()
{
    #ifdef FILE_IO
    freopen("test.in", "r", stdin);
    #endif // FILE_IO
    Init();
    Solve();
    Print();
    return 0;
}