hihocoder #1363 图像算子

Time Limit:10000ms

Case Time Limit:1000ms

Memory Limit:256MB

Description

在图像处理的技术中，经常会用到算子与图像进行卷积运算，从而达到平滑图像或是查找边界的效果。

假设原图为H × W的矩阵A，算子矩阵为D × D的矩阵Op，则处理后的矩阵B大小为(H-D+1) × (W-D+1)。其中：

B[i][j] = ∑(A[i-1+dx][j-1+dy]*Op[dx][dy]) | (dx = 1 .. D, dy = 1 .. D), 1 ≤ i ≤ H-D+1, 1 ≤ j ≤ W-D+1

给定矩阵A和B，以及算子矩阵的边长D。你能求出算子矩阵中每个元素的值吗？

Input

第1行：3个整数，H, W, D，分别表示原图的高度和宽度，以及算子矩阵的大小。5≤H,W≤60，1≤D≤5，D一定是奇数。

第2..H+1行：每行W个整数，第i+1行第j列表示A[i][j]，0≤A[i][j]≤255

接下来H-D+1行：每行W-D+1个整数，表示B[i][j]，B[i][j]在int范围内，可能为负数。

 

输入保证有唯一解，并且解矩阵的每个元素都是整数。

Output

第1..D行：每行D个整数，第i行第j列表示Op[i][j]。

Sample Input

5 5 3
1 6 13 10 3
13 1 5 6 15
8 2 15 0 12
19 19 17 18 18
9 18 19 5 17
22 15 6
35 -36 51
-20 3 -32
 

Sample Output

0 1 0
1 -4 1
0 1 0

Solution:

#include <iostream>
#include <climits>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int H, W, D;

int **img;
int **fimg;
float **matrix;
float *Y;
float *kernel;

void swapRow(int i, int j) {
    for (int k = 0; k < D*D; ++k) {
        swap(matrix[i][k], matrix[j][k]);
    }
}

void print() {
    for (int i = 0; i < H-D+1; ++i) {
        for (int j = 0; j < W-D+1; ++j) {
            for (int s = 0; s < D; ++s) {
                for (int t = 0; t < D; ++t) {
                    printf("%.1f ", matrix[i*(W-D+1)+j][s*D+t]);
                }
            }
            printf("= %.1f\n", Y[i*(W-D+1)+j]);
        }
    }
    printf("\n");

} 

int ftoi(float f) {
    return floor(f+0.01);    
}

void sol() {
    Y = new float[(H-D+1)*(W-D+1)];
    matrix = new float*[(H-D+1)*(W-D+1)];
    for (int i = 0; i < H-D+1; ++i) {
        for (int j = 0; j < W-D+1; ++j) {
            Y[i*(W-D+1)+j] = fimg[i][j];
            matrix[i*(W-D+1)+j] = new float[D*D];
            for (int s = 0; s < D; ++s) {
                for (int t = 0; t < D; ++t) {
                    matrix[i*(W-D+1)+j][s*D+t] = img[i+s][j+t];
                    //printf("%d ", (int)matrix[i*(W-D+1)+j][s*D+t]);
                }
            }
            //printf("= %d\n", (int)Y[i*(W-D+1)+j]);
        }
    }
    //print();
    int len = (H-D+1)*(W-D+1);
    for (int i = 0; i < len; ++i) {
        int t = i;
        for (; t < len; ++t) {
            if (matrix[t][i] != 0) {
                break;
            }
        }
        if (t < len) {
            if (i != t) swapRow(i, t);
        }
        else {
            continue;
        }
        float d = matrix[i][i];
        for (int j = 0; j < D*D; ++j) {
            matrix[i][j] /= d;
        }
        Y[i] /= d;
        
        for (int k = i+1; k < len; ++k) {
            d = matrix[k][i];
            for (int s = i; s < D*D; ++s) {
                matrix[k][s] -= d * matrix[i][s];
            }
            Y[k] -= d*Y[i];
        }
        //print();
    }
    
    kernel = new float[D*D];
    
    for (int i = D*D-1; i >= 0; --i) {
        float f = 0;
        for (int j = D*D-1; j > i; --j) {
            f += kernel[j]*matrix[i][j];
        }
        kernel[i] = Y[i]-f;
    }
    
    for (int i = 0; i < D*D; ++i) {
        printf("%d%c", ftoi(kernel[i]), i%D == D-1 ? '\n' : ' ');
    }
}

int main(int argc, char *argv[]) {
    scanf("%d%d%d", &H, &W, &D);
    img = new int*[H];
    for (int i = 0; i < H; ++i) {
        img[i] = new int[W];
        for (int j = 0; j < W; ++j) {
            scanf("%d", img[i] + j);
        }
    }
    fimg = new int*[H-D+1];
    for (int i = 0; i < H-D+1; ++i) {
        fimg[i] = new int[W-D+1];
        for (int j = 0; j < W-D+1; ++j) {
            scanf("%d", fimg[i] + j);
        }
    }
    
    sol();
}