计算二维数组中的接缝雕刻答案

【问题标题】：Calculating Seam carving in two dimensional array计算二维数组中的接缝雕刻
【发布时间】：2013-05-01 16:17:57
【问题描述】：

    for (int h = 0; h < 4; h++) {

        int minValue = a[h][0];
        for (int i = h; i < h + 1; i++) {
            for (j = w; j < w + 3; j++) {
                if (a[i][j] < minValue) {
                    minValue = a[i][j];

                }

            }
        }
        System.out.println("Minimum Value = " + minValue);

    }

我想找到接缝雕刻，但算法效果不佳。据我所知，我需要在所选索引下找到最小值

【问题讨论】：

我正确地重新格式化了代码，我认为这已经突出了您代码中的几个严重问题（如minValue = a[i][j]; if (a[i][j] == minValue) 和for (int i = h; i < h + 1; i++)，两者都以目前的形式相当无用的构造）所以也许首先检查并修复这些问题，如果您仍然卡住，请返回。
我使用这个 for 循环来检查每一行 //for (int i = h; i
我称那个循环没用，因为实际上并没有迭代（startcondition 将 i 设置为 h 的值，并且一旦 i > h 就停止，也就是说，它将通过一次，值为 h )。

标签： java multidimensional-array seam-carving

【解决方案1】：

我不确定您的代码是否能找到最小接缝：有一种“简单”的动态编程方法可以做到这一点：

private static int[][] findHorizontalSeam(double[][] energyTable) {
        int[][] seam;
        int width = energyTable.length;
        int height = energyTable[0].length;
        // seamDynamic is the table we will use for dynamic programming.
        double[][] seamDynamic = new double[width][height];
        int[][] backtracker = new int[width][height];
        double minimum;
        // horizontal seam.
        seam = new int[energyTable.length][2];

        // Loops over the energy table and finds the lowest energy path.
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                if (x == 0) {
                    seamDynamic[x][y] = energyTable[x][y];
                    backtracker[x][y] = -1;
                } else {
                    // every other column.
                    // need to special case the top/bottom.
                    if (y == 0) {
                        minimum = Math.min(seamDynamic[x - 1][y], seamDynamic[x - 1][y + 1]);
                        if (minimum == seamDynamic[x - 1][y]) {
                            // add backtracker.
                            backtracker[x][y] = 1;
                        } else { // y + 1
                            // add backtracker.
                            backtracker[x][y] = 2;
                        }
                    } else if (y == (height - 1)) {
                        minimum = Math.min(seamDynamic[x - 1][y], seamDynamic[x - 1][y - 1]);
                        if (minimum == seamDynamic[x - 1][y]) {
                            // add backtracker.
                            backtracker[x][y] = 1;
                        } else { // y - 1
                            // add backtracker.
                            backtracker[x][y] = 0;
                        }
                    } else {
                        minimum = Math.min(seamDynamic[x - 1][y - 1], Math.min(seamDynamic[x - 1][y], seamDynamic[x - 1][y + 1]));
                        if (minimum == seamDynamic[x - 1][y - 1]) {
                            // add backtracker.
                            backtracker[x][y] = 0;
                        } else if (minimum == seamDynamic[x - 1][y]) {
                            // add backtracker.
                            backtracker[x][y] = 1;
                        } else { // y + 1
                            // add backtracker.
                            backtracker[x][y] = 2;
                        }
                    }
                    seamDynamic[x][y] = energyTable[x][y] + minimum;
                }
            }
        }

        // now that we have computed the paths, we need to backtrace the minimum one.
        // 0 --> y - 1.
        // 1 --> y.
        // 2 --> y + 1.
        // first we need to find the min at the end.
        double min_num = seamDynamic[width - 1][0];
        int min_index = 0;
        for (int y = 0; y < height; y++) {
            if (min_num > seamDynamic[width - 1][y]) {
                min_index = y;
                min_num = seamDynamic[width - 1][y];
            }
        }

        // now that we have the min we need to backtrace it.
        int y_index = min_index;
        int x_index = width - 1;
        seam[x_index][0] = x_index;
        seam[x_index][1] = y_index;
        int backtrack;
        while (x_index > 0) {
            backtrack = backtracker[x_index][y_index];
            if (backtrack != -1) {
                if (backtrack == 0) {
                    y_index = y_index - 1;
                } else if (backtrack == 1) {
                    y_index = y_index;
                } else { // = 2
                    y_index = y_index + 1;
                }
            } else {
                y_index = y_index;
            }
            x_index = x_index - 1;

            seam[x_index][0] = x_index;
            seam[x_index][1] = y_index;
        }
    }

您可以在 Java here 中找到缝纫机的完整代码。

【讨论】：