diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README.md b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README.md index 79b4728db65de..eaa8562075818 100644 --- a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README.md +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README.md @@ -92,25 +92,350 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3311.Co #### Python3 ```python - +class Solution: + def constructGridLayout(self, n: int, edges: List[List[int]]) -> List[List[int]]: + g = [[] for _ in range(n)] + for u, v in edges: + g[u].append(v) + g[v].append(u) + deg = [-1] * 5 + for x, ys in enumerate(g): + deg[len(ys)] = x + if deg[1] != -1: + row = [deg[1]] + elif deg[4] == -1: + x = deg[2] + for y in g[x]: + if len(g[y]) == 2: + row = [x, y] + break + else: + x = deg[2] + row = [x] + pre = x + x = g[x][0] + while len(g[x]) > 2: + row.append(x) + for y in g[x]: + if y != pre and len(g[y]) < 4: + pre = x + x = y + break + row.append(x) + + ans = [row] + vis = [False] * n + for _ in range(n // len(row) - 1): + for x in row: + vis[x] = True + nxt = [] + for x in row: + for y in g[x]: + if not vis[y]: + nxt.append(y) + break + ans.append(nxt) + row = nxt + return ans ``` #### Java ```java - +class Solution { + public int[][] constructGridLayout(int n, int[][] edges) { + List[] g = new List[n]; + Arrays.setAll(g, k -> new ArrayList<>()); + for (int[] e : edges) { + int u = e[0], v = e[1]; + g[u].add(v); + g[v].add(u); + } + + int[] deg = new int[5]; + Arrays.fill(deg, -1); + + for (int x = 0; x < n; x++) { + deg[g[x].size()] = x; + } + + List row = new ArrayList<>(); + if (deg[1] != -1) { + row.add(deg[1]); + } else if (deg[4] == -1) { + int x = deg[2]; + for (int y : g[x]) { + if (g[y].size() == 2) { + row.add(x); + row.add(y); + break; + } + } + } else { + int x = deg[2]; + row.add(x); + int pre = x; + x = g[x].get(0); + while (g[x].size() > 2) { + row.add(x); + for (int y : g[x]) { + if (y != pre && g[y].size() < 4) { + pre = x; + x = y; + break; + } + } + } + row.add(x); + } + + List> res = new ArrayList<>(); + res.add(new ArrayList<>(row)); + + boolean[] vis = new boolean[n]; + int rowSize = row.size(); + for (int i = 0; i < n / rowSize - 1; i++) { + for (int x : row) { + vis[x] = true; + } + List nxt = new ArrayList<>(); + for (int x : row) { + for (int y : g[x]) { + if (!vis[y]) { + nxt.add(y); + break; + } + } + } + res.add(new ArrayList<>(nxt)); + row = nxt; + } + + int[][] ans = new int[res.size()][rowSize]; + for (int i = 0; i < res.size(); i++) { + for (int j = 0; j < rowSize; j++) { + ans[i][j] = res.get(i).get(j); + } + } + return ans; + } +} ``` #### C++ ```cpp - +class Solution { +public: + vector> constructGridLayout(int n, vector>& edges) { + vector> g(n); + for (auto& e : edges) { + int u = e[0], v = e[1]; + g[u].push_back(v); + g[v].push_back(u); + } + + vector deg(5, -1); + for (int x = 0; x < n; ++x) { + deg[g[x].size()] = x; + } + + vector row; + if (deg[1] != -1) { + row.push_back(deg[1]); + } else if (deg[4] == -1) { + int x = deg[2]; + for (int y : g[x]) { + if (g[y].size() == 2) { + row.push_back(x); + row.push_back(y); + break; + } + } + } else { + int x = deg[2]; + row.push_back(x); + int pre = x; + x = g[x][0]; + while (g[x].size() > 2) { + row.push_back(x); + for (int y : g[x]) { + if (y != pre && g[y].size() < 4) { + pre = x; + x = y; + break; + } + } + } + row.push_back(x); + } + + vector> ans; + ans.push_back(row); + vector vis(n, false); + int rowSize = row.size(); + for (int i = 0; i < n / rowSize - 1; ++i) { + for (int x : row) { + vis[x] = true; + } + vector nxt; + for (int x : row) { + for (int y : g[x]) { + if (!vis[y]) { + nxt.push_back(y); + break; + } + } + } + ans.push_back(nxt); + row = nxt; + } + + return ans; + } +}; ``` #### Go ```go +func constructGridLayout(n int, edges [][]int) [][]int { + g := make([][]int, n) + for _, e := range edges { + u, v := e[0], e[1] + g[u] = append(g[u], v) + g[v] = append(g[v], u) + } + + deg := make([]int, 5) + for i := range deg { + deg[i] = -1 + } + + for x := 0; x < n; x++ { + deg[len(g[x])] = x + } + + var row []int + if deg[1] != -1 { + row = append(row, deg[1]) + } else if deg[4] == -1 { + x := deg[2] + for _, y := range g[x] { + if len(g[y]) == 2 { + row = append(row, x, y) + break + } + } + } else { + x := deg[2] + row = append(row, x) + pre := x + x = g[x][0] + for len(g[x]) > 2 { + row = append(row, x) + for _, y := range g[x] { + if y != pre && len(g[y]) < 4 { + pre = x + x = y + break + } + } + } + row = append(row, x) + } + + ans := [][]int{row} + vis := make([]bool, n) + rowSize := len(row) + for i := 0; i < n/rowSize-1; i++ { + for _, x := range row { + vis[x] = true + } + nxt := []int{} + for _, x := range row { + for _, y := range g[x] { + if !vis[y] { + nxt = append(nxt, y) + break + } + } + } + ans = append(ans, nxt) + row = nxt + } + + return ans +} +``` +#### TypeScript + +```ts +function constructGridLayout(n: number, edges: number[][]): number[][] { + const g: number[][] = Array.from({ length: n }, () => []); + for (const [u, v] of edges) { + g[u].push(v); + g[v].push(u); + } + + const deg: number[] = Array(5).fill(-1); + for (let x = 0; x < n; x++) { + deg[g[x].length] = x; + } + + let row: number[] = []; + if (deg[1] !== -1) { + row.push(deg[1]); + } else if (deg[4] === -1) { + let x = deg[2]; + for (const y of g[x]) { + if (g[y].length === 2) { + row.push(x, y); + break; + } + } + } else { + let x = deg[2]; + row.push(x); + let pre = x; + x = g[x][0]; + while (g[x].length > 2) { + row.push(x); + for (const y of g[x]) { + if (y !== pre && g[y].length < 4) { + pre = x; + x = y; + break; + } + } + } + row.push(x); + } + + const ans: number[][] = [row]; + const vis: boolean[] = Array(n).fill(false); + const rowSize = row.length; + + for (let i = 0; i < Math.floor(n / rowSize) - 1; i++) { + for (const x of row) { + vis[x] = true; + } + const nxt: number[] = []; + for (const x of row) { + for (const y of g[x]) { + if (!vis[y]) { + nxt.push(y); + break; + } + } + } + ans.push(nxt); + row = nxt; + } + + return ans; +} ``` diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README_EN.md b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README_EN.md index 3ceaf919d30a2..bbb2af53f4241 100644 --- a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README_EN.md +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/README_EN.md @@ -90,25 +90,350 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3311.Co #### Python3 ```python - +class Solution: + def constructGridLayout(self, n: int, edges: List[List[int]]) -> List[List[int]]: + g = [[] for _ in range(n)] + for u, v in edges: + g[u].append(v) + g[v].append(u) + deg = [-1] * 5 + for x, ys in enumerate(g): + deg[len(ys)] = x + if deg[1] != -1: + row = [deg[1]] + elif deg[4] == -1: + x = deg[2] + for y in g[x]: + if len(g[y]) == 2: + row = [x, y] + break + else: + x = deg[2] + row = [x] + pre = x + x = g[x][0] + while len(g[x]) > 2: + row.append(x) + for y in g[x]: + if y != pre and len(g[y]) < 4: + pre = x + x = y + break + row.append(x) + + ans = [row] + vis = [False] * n + for _ in range(n // len(row) - 1): + for x in row: + vis[x] = True + nxt = [] + for x in row: + for y in g[x]: + if not vis[y]: + nxt.append(y) + break + ans.append(nxt) + row = nxt + return ans ``` #### Java ```java - +class Solution { + public int[][] constructGridLayout(int n, int[][] edges) { + List[] g = new List[n]; + Arrays.setAll(g, k -> new ArrayList<>()); + for (int[] e : edges) { + int u = e[0], v = e[1]; + g[u].add(v); + g[v].add(u); + } + + int[] deg = new int[5]; + Arrays.fill(deg, -1); + + for (int x = 0; x < n; x++) { + deg[g[x].size()] = x; + } + + List row = new ArrayList<>(); + if (deg[1] != -1) { + row.add(deg[1]); + } else if (deg[4] == -1) { + int x = deg[2]; + for (int y : g[x]) { + if (g[y].size() == 2) { + row.add(x); + row.add(y); + break; + } + } + } else { + int x = deg[2]; + row.add(x); + int pre = x; + x = g[x].get(0); + while (g[x].size() > 2) { + row.add(x); + for (int y : g[x]) { + if (y != pre && g[y].size() < 4) { + pre = x; + x = y; + break; + } + } + } + row.add(x); + } + + List> res = new ArrayList<>(); + res.add(new ArrayList<>(row)); + + boolean[] vis = new boolean[n]; + int rowSize = row.size(); + for (int i = 0; i < n / rowSize - 1; i++) { + for (int x : row) { + vis[x] = true; + } + List nxt = new ArrayList<>(); + for (int x : row) { + for (int y : g[x]) { + if (!vis[y]) { + nxt.add(y); + break; + } + } + } + res.add(new ArrayList<>(nxt)); + row = nxt; + } + + int[][] ans = new int[res.size()][rowSize]; + for (int i = 0; i < res.size(); i++) { + for (int j = 0; j < rowSize; j++) { + ans[i][j] = res.get(i).get(j); + } + } + return ans; + } +} ``` #### C++ ```cpp - +class Solution { +public: + vector> constructGridLayout(int n, vector>& edges) { + vector> g(n); + for (auto& e : edges) { + int u = e[0], v = e[1]; + g[u].push_back(v); + g[v].push_back(u); + } + + vector deg(5, -1); + for (int x = 0; x < n; ++x) { + deg[g[x].size()] = x; + } + + vector row; + if (deg[1] != -1) { + row.push_back(deg[1]); + } else if (deg[4] == -1) { + int x = deg[2]; + for (int y : g[x]) { + if (g[y].size() == 2) { + row.push_back(x); + row.push_back(y); + break; + } + } + } else { + int x = deg[2]; + row.push_back(x); + int pre = x; + x = g[x][0]; + while (g[x].size() > 2) { + row.push_back(x); + for (int y : g[x]) { + if (y != pre && g[y].size() < 4) { + pre = x; + x = y; + break; + } + } + } + row.push_back(x); + } + + vector> ans; + ans.push_back(row); + vector vis(n, false); + int rowSize = row.size(); + for (int i = 0; i < n / rowSize - 1; ++i) { + for (int x : row) { + vis[x] = true; + } + vector nxt; + for (int x : row) { + for (int y : g[x]) { + if (!vis[y]) { + nxt.push_back(y); + break; + } + } + } + ans.push_back(nxt); + row = nxt; + } + + return ans; + } +}; ``` #### Go ```go +func constructGridLayout(n int, edges [][]int) [][]int { + g := make([][]int, n) + for _, e := range edges { + u, v := e[0], e[1] + g[u] = append(g[u], v) + g[v] = append(g[v], u) + } + + deg := make([]int, 5) + for i := range deg { + deg[i] = -1 + } + + for x := 0; x < n; x++ { + deg[len(g[x])] = x + } + + var row []int + if deg[1] != -1 { + row = append(row, deg[1]) + } else if deg[4] == -1 { + x := deg[2] + for _, y := range g[x] { + if len(g[y]) == 2 { + row = append(row, x, y) + break + } + } + } else { + x := deg[2] + row = append(row, x) + pre := x + x = g[x][0] + for len(g[x]) > 2 { + row = append(row, x) + for _, y := range g[x] { + if y != pre && len(g[y]) < 4 { + pre = x + x = y + break + } + } + } + row = append(row, x) + } + + ans := [][]int{row} + vis := make([]bool, n) + rowSize := len(row) + for i := 0; i < n/rowSize-1; i++ { + for _, x := range row { + vis[x] = true + } + nxt := []int{} + for _, x := range row { + for _, y := range g[x] { + if !vis[y] { + nxt = append(nxt, y) + break + } + } + } + ans = append(ans, nxt) + row = nxt + } + + return ans +} +``` +#### TypeScript + +```ts +function constructGridLayout(n: number, edges: number[][]): number[][] { + const g: number[][] = Array.from({ length: n }, () => []); + for (const [u, v] of edges) { + g[u].push(v); + g[v].push(u); + } + + const deg: number[] = Array(5).fill(-1); + for (let x = 0; x < n; x++) { + deg[g[x].length] = x; + } + + let row: number[] = []; + if (deg[1] !== -1) { + row.push(deg[1]); + } else if (deg[4] === -1) { + let x = deg[2]; + for (const y of g[x]) { + if (g[y].length === 2) { + row.push(x, y); + break; + } + } + } else { + let x = deg[2]; + row.push(x); + let pre = x; + x = g[x][0]; + while (g[x].length > 2) { + row.push(x); + for (const y of g[x]) { + if (y !== pre && g[y].length < 4) { + pre = x; + x = y; + break; + } + } + } + row.push(x); + } + + const ans: number[][] = [row]; + const vis: boolean[] = Array(n).fill(false); + const rowSize = row.length; + + for (let i = 0; i < Math.floor(n / rowSize) - 1; i++) { + for (const x of row) { + vis[x] = true; + } + const nxt: number[] = []; + for (const x of row) { + for (const y of g[x]) { + if (!vis[y]) { + nxt.push(y); + break; + } + } + } + ans.push(nxt); + row = nxt; + } + + return ans; +} ``` diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.cpp b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.cpp new file mode 100644 index 0000000000000..e089a15902978 --- /dev/null +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.cpp @@ -0,0 +1,69 @@ +class Solution { +public: + vector> constructGridLayout(int n, vector>& edges) { + vector> g(n); + for (auto& e : edges) { + int u = e[0], v = e[1]; + g[u].push_back(v); + g[v].push_back(u); + } + + vector deg(5, -1); + for (int x = 0; x < n; ++x) { + deg[g[x].size()] = x; + } + + vector row; + if (deg[1] != -1) { + row.push_back(deg[1]); + } else if (deg[4] == -1) { + int x = deg[2]; + for (int y : g[x]) { + if (g[y].size() == 2) { + row.push_back(x); + row.push_back(y); + break; + } + } + } else { + int x = deg[2]; + row.push_back(x); + int pre = x; + x = g[x][0]; + while (g[x].size() > 2) { + row.push_back(x); + for (int y : g[x]) { + if (y != pre && g[y].size() < 4) { + pre = x; + x = y; + break; + } + } + } + row.push_back(x); + } + + vector> ans; + ans.push_back(row); + vector vis(n, false); + int rowSize = row.size(); + for (int i = 0; i < n / rowSize - 1; ++i) { + for (int x : row) { + vis[x] = true; + } + vector nxt; + for (int x : row) { + for (int y : g[x]) { + if (!vis[y]) { + nxt.push_back(y); + break; + } + } + } + ans.push_back(nxt); + row = nxt; + } + + return ans; + } +}; diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.go b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.go new file mode 100644 index 0000000000000..e2daf33cd7f38 --- /dev/null +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.go @@ -0,0 +1,68 @@ +func constructGridLayout(n int, edges [][]int) [][]int { + g := make([][]int, n) + for _, e := range edges { + u, v := e[0], e[1] + g[u] = append(g[u], v) + g[v] = append(g[v], u) + } + + deg := make([]int, 5) + for i := range deg { + deg[i] = -1 + } + + for x := 0; x < n; x++ { + deg[len(g[x])] = x + } + + var row []int + if deg[1] != -1 { + row = append(row, deg[1]) + } else if deg[4] == -1 { + x := deg[2] + for _, y := range g[x] { + if len(g[y]) == 2 { + row = append(row, x, y) + break + } + } + } else { + x := deg[2] + row = append(row, x) + pre := x + x = g[x][0] + for len(g[x]) > 2 { + row = append(row, x) + for _, y := range g[x] { + if y != pre && len(g[y]) < 4 { + pre = x + x = y + break + } + } + } + row = append(row, x) + } + + ans := [][]int{row} + vis := make([]bool, n) + rowSize := len(row) + for i := 0; i < n/rowSize-1; i++ { + for _, x := range row { + vis[x] = true + } + nxt := []int{} + for _, x := range row { + for _, y := range g[x] { + if !vis[y] { + nxt = append(nxt, y) + break + } + } + } + ans = append(ans, nxt) + row = nxt + } + + return ans +} diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.java b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.java new file mode 100644 index 0000000000000..6ed8b2c27001d --- /dev/null +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.java @@ -0,0 +1,78 @@ +class Solution { + public int[][] constructGridLayout(int n, int[][] edges) { + List[] g = new List[n]; + Arrays.setAll(g, k -> new ArrayList<>()); + for (int[] e : edges) { + int u = e[0], v = e[1]; + g[u].add(v); + g[v].add(u); + } + + int[] deg = new int[5]; + Arrays.fill(deg, -1); + + for (int x = 0; x < n; x++) { + deg[g[x].size()] = x; + } + + List row = new ArrayList<>(); + if (deg[1] != -1) { + row.add(deg[1]); + } else if (deg[4] == -1) { + int x = deg[2]; + for (int y : g[x]) { + if (g[y].size() == 2) { + row.add(x); + row.add(y); + break; + } + } + } else { + int x = deg[2]; + row.add(x); + int pre = x; + x = g[x].get(0); + while (g[x].size() > 2) { + row.add(x); + for (int y : g[x]) { + if (y != pre && g[y].size() < 4) { + pre = x; + x = y; + break; + } + } + } + row.add(x); + } + + List> res = new ArrayList<>(); + res.add(new ArrayList<>(row)); + + boolean[] vis = new boolean[n]; + int rowSize = row.size(); + for (int i = 0; i < n / rowSize - 1; i++) { + for (int x : row) { + vis[x] = true; + } + List nxt = new ArrayList<>(); + for (int x : row) { + for (int y : g[x]) { + if (!vis[y]) { + nxt.add(y); + break; + } + } + } + res.add(new ArrayList<>(nxt)); + row = nxt; + } + + int[][] ans = new int[res.size()][rowSize]; + for (int i = 0; i < res.size(); i++) { + for (int j = 0; j < rowSize; j++) { + ans[i][j] = res.get(i).get(j); + } + } + return ans; + } +} diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.py b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.py new file mode 100644 index 0000000000000..49ef04e949bee --- /dev/null +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.py @@ -0,0 +1,45 @@ +class Solution: + def constructGridLayout(self, n: int, edges: List[List[int]]) -> List[List[int]]: + g = [[] for _ in range(n)] + for u, v in edges: + g[u].append(v) + g[v].append(u) + deg = [-1] * 5 + for x, ys in enumerate(g): + deg[len(ys)] = x + if deg[1] != -1: + row = [deg[1]] + elif deg[4] == -1: + x = deg[2] + for y in g[x]: + if len(g[y]) == 2: + row = [x, y] + break + else: + x = deg[2] + row = [x] + pre = x + x = g[x][0] + while len(g[x]) > 2: + row.append(x) + for y in g[x]: + if y != pre and len(g[y]) < 4: + pre = x + x = y + break + row.append(x) + + ans = [row] + vis = [False] * n + for _ in range(n // len(row) - 1): + for x in row: + vis[x] = True + nxt = [] + for x in row: + for y in g[x]: + if not vis[y]: + nxt.append(y) + break + ans.append(nxt) + row = nxt + return ans diff --git a/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.ts b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.ts new file mode 100644 index 0000000000000..96b97a504d0ad --- /dev/null +++ b/solution/3300-3399/3311.Construct 2D Grid Matching Graph Layout/Solution.ts @@ -0,0 +1,64 @@ +function constructGridLayout(n: number, edges: number[][]): number[][] { + const g: number[][] = Array.from({ length: n }, () => []); + for (const [u, v] of edges) { + g[u].push(v); + g[v].push(u); + } + + const deg: number[] = Array(5).fill(-1); + for (let x = 0; x < n; x++) { + deg[g[x].length] = x; + } + + let row: number[] = []; + if (deg[1] !== -1) { + row.push(deg[1]); + } else if (deg[4] === -1) { + let x = deg[2]; + for (const y of g[x]) { + if (g[y].length === 2) { + row.push(x, y); + break; + } + } + } else { + let x = deg[2]; + row.push(x); + let pre = x; + x = g[x][0]; + while (g[x].length > 2) { + row.push(x); + for (const y of g[x]) { + if (y !== pre && g[y].length < 4) { + pre = x; + x = y; + break; + } + } + } + row.push(x); + } + + const ans: number[][] = [row]; + const vis: boolean[] = Array(n).fill(false); + const rowSize = row.length; + + for (let i = 0; i < Math.floor(n / rowSize) - 1; i++) { + for (const x of row) { + vis[x] = true; + } + const nxt: number[] = []; + for (const x of row) { + for (const y of g[x]) { + if (!vis[y]) { + nxt.push(y); + break; + } + } + } + ans.push(nxt); + row = nxt; + } + + return ans; +}