1260. 二维网格迁移

package com.heu.wsq.leetcode.arr;

import java.util.ArrayList;
import java.util.List;

/**
 * 1260. 二维网格迁移
 * @author wsq
 * @date 2021/1/15
 * 给你一个 m 行 n 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。
 *
 * 每次「迁移」操作将会引发下述活动：
 *
 * 位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。
 * 位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]。
 * 位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。
 * 请你返回 k 次迁移操作后最终得到的 二维网格。
 *
 *  示例 1：
 * 输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
 * 输出：[[9,1,2],[3,4,5],[6,7,8]]
 *
 * 链接：https://leetcode-cn.com/problems/shift-2d-grid
 */
public class ShiftGrid {
    /**
     * 将二维数组转为一维数组，将原有问题转为一维数组上的数字循环移动，
     * 采用翻转的方式进行一维数组上的数字循环移动。
     * @param grid
     * @param k
     * @return
     */
    public List<List<Integer>> shiftGrid(int[][] grid, int k) {
        int n = grid.length;
        if (n == 0){
            return new ArrayList<>();
        }
        int m = grid[0].length;
        int[] arr = new int[n * m];
        int pos = 0;
        for (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                arr[pos++] = grid[i][j];
            }
        }
        k %= n * m;
        reverse(arr, 0, n * m - 1);
        reverse(arr, 0, k - 1);
        reverse(arr, k, n * m - 1);
        List<List<Integer>> ans = new ArrayList<>();
        for (int i = 0; i < n; i++){
            List<Integer> list = new ArrayList<>();
            for (int j = 0; j < m; j++){
                list.add(arr[i * m + j]);
            }
            ans.add(list);
        }
        return ans;
    }

    private void reverse(int[] arr, int k, int i) {
        while (k < i){
            int tmp = arr[k];
            arr[k] = arr[i];
            arr[i] = tmp;
        }
    }
}