1035. Uncrossed Lines

using System;
using System.Collections.Generic;
public class Solution {
    public int[][] AllCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        var cells = new List<(int, int, int)>();
        
        for (int r = 0; r < rows; ++r) {
            for (int c = 0; c < cols; ++c) {
                int distance = Math.Abs(r - rCenter) + Math.Abs(c - cCenter);
                cells.Add((distance, r, c));
            }
        }
        
        cells.Sort((a, b) => a.Item1.CompareTo(b.Item1));
        
        var result = new List<int[]>();
        foreach (var cell in cells) {
            result.Add(new int[] { cell.Item2, cell.Item3 });
        }
        
        return result.ToArray();
    }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int[][] AllCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        var cells = new List<(int, int, int)>();
        
        for (int r = 0; r < rows; ++r) {
            for (int c = 0; c < cols; ++c) {
                int distance = abs(r - rCenter) + abs(c - cCenter);
                cells.push_back((distance, r, c));
            }
        }
        
        cells.Sort((a, b) => a.Item1.CompareTo(b.Item1));
        
        var result = new List<int[]>();
        foreach (var cell in cells) {
            result.push_back(new int[] { cell.Item2, cell.Item3 });
        }
        
        return result.ToArray();
    }
}

import java.util.*;

public class Solution {
    public int[][] allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        List<int[]> cells = new ArrayList<>();
        
        for (int r = 0; r < rows; ++r) {
            for (int c = 0; c < cols; ++c) {
                int distance = Math.abs(r - rCenter) + Math.abs(c - cCenter);
                cells.add(new int[] { distance, r, c });
            }
        }
        
        cells.sort((a, b) -> Integer.compare(a[0], b[0]));
        
        int[][] result = new int[cells.size()][2];
        for (int i = 0; i < cells.size(); ++i) {
            result[i][0] = cells.get(i)[1];
            result[i][1] = cells.get(i)[2];
        }
        
        return result;
    }
}

var allCellsDistOrder = function(rows, cols, rCenter, cCenter) {
    const cells = [];
    
    for (let r = 0; r < rows; r++) {
        for (let c = 0; c < cols; c++) {
            const distance = Math.abs(r - rCenter) + Math.abs(c - cCenter);
            cells.push([distance, r, c]);
        }
    }
    
    cells.sort((a, b) => a[0] - b[0]);
    
    return cells.map(cell => [cell[1], cell[2]]);
};

def maxUncrossedLines(nums1, nums2):
    m, n = len(nums1), len(nums2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if nums1[i - 1] == nums2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

    return dp[m][n]

import (
    "sort"
    "math"
)

func allCellsDistOrder(rows int, cols int, rCenter int, cCenter int) [][]int {
    cells := make([][3]int, 0, rows*cols)
    
    for r := 0; r < rows; r++ {
        for c := 0; c < cols; c++ {
            distance := int(math.Abs(float64(r - rCenter)) + math.Abs(float64(c - cCenter)))
            cells = append(cells, [3]int{distance, r, c})
        }
    }
    
    sort.Slice(cells, func(i, j int) bool {
        return cells[i][0] < cells[j][0]
    })
    
    result := make([][]int, len(cells))
    for i, cell := range cells {
        result[i] = []int{cell[1], cell[2]}
    }
    
    return result
}

Algorithm

1⃣Définition задачи как задачи о нахождении наибольшей общей подпоследовательности (LCS):

Эта Problème является классической задачей динамического программирования, где нам нужно find максимальную длину наибольшей общей подпоследовательности (LCS) между nums1 и nums2.

2⃣Построение таблицы динамического программирования:

Создайте двумерный tableau dp, где dp[i][j] будет представлять длину наибольшей общей подпоследовательности для подtableauов nums1[0..i-1] и nums2[0..j-1].

Инициализируйте первый ряд и первый столбец нулями, так как если один из tableauов пуст, LCS также будет пустым.

3⃣Заполнение таблицы динамического программирования:

Пройдите по elementам tableauов nums1 и nums2. Если текущие elementы совпадают, увеличьте значение ячейки dp[i][j] на 1 от диагонального значения dp[i-1][j-1]. Если не совпадают, установите значение ячейки dp[i][j] как максимальное из значений dp[i-1][j] и dp[i][j-1].

Результат будет находиться в ячейке dp[nums1.length][nums2.length].

😎