程式師世界 >> 編程語言 >> C語言 >> C++ >> C++入門知識 >> POJ3150---Cellular Automaton(矩陣)

POJ3150---Cellular Automaton(矩陣)

編輯：C++入門知識

POJ3150---Cellular Automaton(矩陣)

Description

A cellular automaton is a collection of cells on a grid of specified shape that evolves through a number of discrete time steps according to a set of rules that describe the new state of a cell based on the states of neighboring cells. The order of the cellular automaton is the number of cells it contains. Cells of the automaton of order n are numbered from 1 to n.

The order of the cell is the number of different values it may contain. Usually, values of a cell of order m are considered to be integer numbers from 0 to m ? 1.

One of the most fundamental properties of a cellular automaton is the type of grid on which it is computed. In this problem we examine the special kind of cellular automaton — circular cellular automaton of order n with cells of order m. We will denote such kind of cellular automaton as n,m-automaton.

A distance between cells i and j in n,m-automaton is defined as min(|i ? j|, n ? |i ? j|). A d-environment of a cell is the set of cells at a distance not greater than d.

On each d-step values of all cells are simultaneously replaced by new values. The new value of cell i after d-step is computed as a sum of values of cells belonging to the d-enviroment of the cell i modulo m.

The following picture shows 1-step of the 5,3-automaton.

The problem is to calculate the state of the n,m-automaton after k d-steps.

Input

The first line of the input file contains four integer numbers n, m, d, and k (1 ≤ n ≤ 500, 1 ≤ m ≤ 1 000 000, 0 ≤ d < n?2 , 1 ≤ k ≤ 10 000 000). The second line contains n integer numbers from 0 to m ? 1 — initial values of the automaton’s cells.

Output

Output the values of the n,m-automaton’s cells after k d-steps.

Sample Input

sample input #1
5 3 1 1
1 2 2 1 2

sample input #2
5 3 1 10
1 2 2 1 2

Sample Output

sample output #1
2 2 2 2 1

sample output #2
2 0 0 2 2

Source
Northeastern Europe 2006

容易推出轉移矩陣,但是規模太大,還不行
觀察發現這個矩陣的每一行都是循環的,下一行的就是上一行向右循環移動一位,所以我們可以把矩陣乘法降到n^2,只用一維數組來保存,這樣再結合矩陣快速冪就可以ac了

/*************************************************************************
    > File Name: POJ3150.cpp
    > Author: ALex
    > Mail: [email protected] 
    > Created Time: 2015年03月17日 星期二 20時42分20秒
 ************************************************************************/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double eps = 1e-15;
typedef long long LL;
typedef pair  PLL;

LL mat[505][505];
LL base[505];
LL arr[505];
LL tmp[505];
LL init[505];
int n, m, d, k;

void mul (LL a[])
{
    for (int j = 1; j <= n; ++j)
    {
        tmp[j] = 0;
        for (int i = 1; i <= n; ++i)
        {
            tmp[j] += mat[i][j] * a[i]; 
            tmp[j] %= m;
        }
    }
    for (int i = 1; i <= n; ++i)
    {
        a[i] = tmp[i];
    }
}

void fastpow()
{
    while (k)
    {
        if (k & 1)
        {
            mul (arr);
        }
        k >>= 1;
        mul (base);
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j <= n; ++j)
            {
                int p = (j + i - 1) % n;
                if (!p)
                {
                    p = n;
                }
                mat[i][p] = base[j];
            }
        }
    }
}

int main ()
{
    while (~scanf("%d%d%d%d", &n, &m, &d, &k))
    {
        for (int i = 1; i <= n; ++i)
        {
            scanf("%lld", &init[i]);
        }
        for (int j = 1; j <= n; ++j)
        {
            for (int i = 1; i <= n; ++i)
            {
                int dis = min (abs(i - j), n - abs(i - j));
                if (dis <= d)
                { 
                    mat[i][j] = 1;
                }
            }
        }
        memset (arr, 0, sizeof(arr));
        arr[1] = 1; //單位矩陣
        for (int i = 1; i <= n; ++i)
        {
            base[i] = mat[1][i];
        }
        fastpow();
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j <= n; ++j)
            {
                int p = (j + i - 1) % n;
                if (!p)
                {
                    p = n;
                }
                mat[i][p] = arr[j];
            }
        }
        mul(init);
        for (int i = 1; i <= n; ++i)
        {
            printf("%lld", init[i]);
            if (i < n)
            {
                printf(" ");
            }
        }
        printf("\n");
    }
    return 0;
}