add hyup2 and ...

storage/hyup2/rs/01_05.rs

@@ -0,0 +1,8 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+}

storage/hyup2/rs/completed/01_01.rs

@@ -0,0 +1,30 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+
+    let grid: Vec<Vec<usize>> = (0..n)
+        .map(|_| (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>())
+        .collect();
+
+    let mut maxima = 0;
+    for i in 1..n - 1 {
+        for j in 1..n - 1 {
+            let mut s = 0;
+            for ii in 0..3 {
+                for jj in 0..3 {
+                    s += grid[i + ii - 1][j + jj - 1];
+                }
+            }
+
+            maxima = std::cmp::max(maxima, s);
+        }
+    }
+
+    println!("{}", maxima);
+}

storage/hyup2/rs/completed/01_02.rs

@@ -0,0 +1,57 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap();
+
+    let grid: Vec<Vec<usize>> = (0..n)
+        .map(|_| (0..n).map(|_| iter.next().unwrap()).collect())
+        .collect();
+
+    let mut cnt = 0;
+
+    for i in 0..n {
+        let mut prev = 101;
+        let mut succ = 1;
+
+        for j in 0..n {
+            if grid[i][j] == prev {
+                succ += 1;
+            } else {
+                prev = grid[i][j];
+                succ = 1;
+            }
+
+            if succ == m {
+                cnt += 1;
+                break;
+            }
+        }
+    }
+
+    for i in 0..n {
+        let mut prev = 101;
+        let mut succ = 1;
+
+        for j in 0..n {
+            if grid[j][i] == prev {
+                succ += 1;
+            } else {
+                prev = grid[j][i];
+                succ = 1;
+            }
+
+            if succ == m {
+                cnt += 1;
+                break;
+            }
+        }
+    }
+
+    println!("{}", cnt);
+}

storage/hyup2/rs/completed/01_03.rs

@@ -0,0 +1,60 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap();
+
+    let grid: Vec<Vec<usize>> = (0..n)
+        .map(|_| (0..m).map(|_| iter.next().unwrap()).collect())
+        .collect();
+
+    let mut maxima = 0;
+
+    //
+    for i in (0..n - 1) {
+        for j in (0..m - 1) {
+            let s = grid[i][j] + grid[i][j + 1] + grid[i + 1][j] + grid[i + 1][j + 1];
+
+            let m = [
+                s - grid[i][j],
+                s - grid[i][j + 1],
+                s - grid[i + 1][j],
+                s - grid[i + 1][j + 1],
+            ]
+            .into_iter()
+            .max().unwrap();
+
+            if m > maxima {
+                maxima = m;
+            }
+        }
+    }
+    //
+    for i in (0..n - 2) {
+        for j in (0..m) {
+            let s = grid[i][j] + grid[i + 1][j] + grid[i + 2][j];
+
+            if s > maxima {
+                maxima = s;
+            }
+        }
+    }
+
+    //
+    for i in (0..n) {
+        for j in (0..m - 2) {
+            let s = grid[i][j] + grid[i][j + 1] + grid[i][j + 2];
+
+            if s > maxima {
+                maxima = s;
+            }
+        }
+    }
+
+    println!("{}", maxima);
+}

storage/hyup2/rs/completed/01_04.rs

@@ -0,0 +1,50 @@
+use std::io::{read_to_string, stdin};
+
+fn cost(k: i64) -> i64 {
+    k * k + (k + 1) * (k + 1)
+}
+
+fn drill(field: &Vec<Vec<i64>>, n: usize, k: i64, r: usize, c:usize) -> i64 {
+    if k == 0 {
+        return field[r][c];
+    } else {
+        let mut s = 0;
+        for i in 0..n {
+            for j in 0..n {
+                if (i as i64 - r as i64).abs() + (j as i64 - c as i64).abs() <= k {
+                    s += field[i][j];
+                }
+            }
+        }
+        s
+    }
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap() as i64;
+    let mut maxima = 0;
+
+    let mut field = vec![vec![0; n]; n];
+    for i in 0..n {
+        for j in 0..n {
+            field[i][j] = iter.next().unwrap() as i64;
+        }
+    }
+    for i in 0..n {
+        for j in 0..n {
+            for ii in 0..20 {
+                let s = drill(&field, n, ii, i, j);
+                if s * m >= cost(ii) {
+                    maxima = maxima.max(s);
+                }
+            }
+        }
+    }
+    println!("{}", maxima);
+}