Resumen de tonos de llamada 798 - Rotación mínima con puntaje más alto

Enlace del título original: hebilla de fuerza

describir:

Dada una matriz nums, podemos rotarla por un entero no negativo k para que la matriz se convierta en [nums[k], nums[k + 1], ... nums[nums.length - 1] , nums[0] , números[1], ..., números[k-1]] . A partir de entonces, cualquier artículo con un valor menor o igual a su índice se puede contar como un punto.

Por ejemplo, la matriz es nums = [2,4,1,3,0], después de rotar por k = 2, se convierte en [1,3,0,2,4]. Esto contará como 3 puntos porque 1 > 0 [no cuenta], 3 > 1 [no cuenta], 0 <= 2 [cuenta 1 punto], 2 <= 3 [cuenta 1 punto], 4 <= 4 [ cuenta 1 punto].
En todas las rotaciones posibles, devolver el índice de rotación k correspondiente a la puntuación más alta que podamos obtener. Si hay varias respuestas, devuelva el subíndice k más pequeño que satisfaga la condición.

Ejemplo 1:

Entrada: nums = [2,3,1,4,0]
Salida: 3
Explicación:
La puntuación de cada k se muestra a continuación:
k = 0, nums = [2,3,1,4,0], puntuación 2
k = 1, nums = [3,1,4,0,2], puntaje 3
k = 2, nums = [1,4,0,2,3], puntaje 3
k = 3, nums = [4,0 , 2,3,1], puntuación 4
k = 4, nums = [0,2,3,1,4], puntuación 3,
por lo que debemos elegir k = 3, la puntuación más alta.
Ejemplo 2:

Entrada: nums = [1,3,0,2,4]
Salida: 0
Explicación:
nums siempre tiene 3 puntos sin importar cómo cambie.
Entonces elegiremos el k más pequeño, que es 0.
 

insinuación:

1 <= nums.longitud <= 105
0 <= nums[i] < nums.longitud

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/smallest-rotation-with-highest-score Los
derechos de autor pertenecen a Leetcode.com. Para reimpresiones comerciales, comuníquese con la autorización oficial y para reimpresiones no comerciales, indique la fuente.

Ideas para resolver problemas:

* Ideas para resolver problemas: 
* La longitud de esta pregunta es 10^5, por lo que la complejidad del tiempo debe ser menor que O(n*lgN), así que primero intente la solución de nivel O(n). 
* Encontramos que la transformación es en realidad regular, dividí el valor correspondiente de la atmósfera en 3 tipos: 
* 1. El valor es 0 y cualquier movimiento se cumple. 
2. No mover aquellos que cumplan las condiciones. 
* 3. Quedará satisfecho después de mudarse. 
* Para el primero, no nos importa. 
* En el segundo tipo, después de moverse, la condición no se cumplirá, y continuar moviéndose hará que la condición se cumpla nuevamente. Por ejemplo, si value=2 está en la posición de index=3, la condición no se cumple después de moverse 2 veces. Después de moverse 4 veces, conduce a la alineación y la condición se cumple nuevamente. 
* El tercer tipo, la condición se cumple después de moverse varias veces, y la condición no se vuelve a cumplir después de continuar moviéndose. 
* Registramos donde se encuentra y no se encuentra. 
* Usamos datos para registrar, la matriz de datos[1], que representa el cambio causado por mover 1 bit. data[1][0] representa el número que provocó que se cumpliera la condición, y data[1][1] representa el número que provocó la insatisfacción. 
* Después de calcular los datos, es conveniente sumar y restar los datos según el valor inicial, y luego se puede obtener el valor máximo.

Código:

public class Solution798 {

    public int bestRotation(int[] nums) {
        int[][] data = new int[nums.length][2];
        int currentSum = 0;
        for (int i = 0; i < nums.length; i++) {
            int value = nums[i];
            //加入
            int addIndex;
            //移除
            int removeIndex;

            if (value <= i) {
                currentSum++;
                addIndex = i + 1;
                removeIndex = i - value + 1;
            } else {
                addIndex = i + 1;
                removeIndex = nums.length - value + i + 1;
            }
            if (addIndex >= nums.length) {
                addIndex = addIndex - nums.length;
            }
            if (removeIndex >= nums.length) {
                removeIndex = removeIndex - nums.length;
            }
            if (value == 0) {
                continue;
            }
            data[addIndex][0]++;
            data[removeIndex][1]++;
        }
        int maxSum = currentSum;
        int result = 0;
        for (int i = 1; i < nums.length; i++) {
            currentSum += data[i][0];
            currentSum -= data[i][1];
            if (currentSum > maxSum) {
                result = i;
                maxSum = currentSum;
            }
        }
        return result;
    }


}