y

Author: KSH-code

.vscode/settings.json

@@ -43,6 +43,7 @@
         "fstream": "cpp",
         "limits": "cpp",
         "sstream": "cpp",
-        "typeinfo": "cpp"
+        "typeinfo": "cpp",
+        "queue": "cpp"
     }
 }

1600

@@ -0,0 +1,78 @@
+#include <iostream>
+#include <queue>
+using namespace std;
+typedef long long ll;
+
+struct Node
+{
+    int x, y, z, count;
+};
+
+int xxxx[] = {-1, 0, 1, 0};
+int yyyy[] = {0, 1, 0, -1};
+
+void solve()
+{
+    int N, M, K;
+    cin >> K >> M >> N;
+    int map[N][M];
+    for (int i = 0; i < N; i++)
+        for (int j = 0; j < M; j++)
+            cin >> map[i][j];
+
+    int counts[N][M][K + 1];
+    for (int i = 0; i < N; i++)
+        for (int j = 0; j < M; j++)
+            for (int k = 0; k <= K; k++)
+                counts[i][j][k] = 1e9;
+
+    queue<Node> q;
+    q.push({0, 0, 0, 0});
+    while (q.size())
+    {
+        auto [x, y, z, count] = q.front();
+        if (x == N - 1 && y == M - 1)
+        {
+            cout << count;
+            return;
+        }
+        int next_count = count + 1;
+        q.pop();
+
+        for (int i = 0; i < 4; i++)
+        {
+            int next_x = x + xxxx[i];
+            int next_y = y + yyyy[i];
+            if (next_x < 0 || next_y < 0 || next_x >= N || next_y >= M || map[next_x][next_y] == 1)
+                continue;
+            if (counts[next_x][next_y][z] <= next_count)
+                continue;
+            counts[next_x][next_y][z] = next_count;
+            q.push({next_x, next_y, z, next_count});
+        }
+        if (z + 1 <= K)
+        {
+            int xxxxxxxx[] = {-1, -2, -2, -1, 1, 2, 2, 1};
+            int yyyyyyyy[] = {-2, -1, 1, 2, 2, 1, -1, -2};
+            for (int i = 0; i < 8; i++)
+            {
+                int next_x = x + xxxxxxxx[i];
+                int next_y = y + yyyyyyyy[i];
+                int next_z = z + 1;
+                if (next_x < 0 || next_y < 0 || next_x >= N || next_y >= M || map[next_x][next_y] == 1)
+                    continue;
+                if (counts[next_x][next_y][next_z] <= next_count)
+                    continue;
+                counts[next_x][next_y][next_z] = next_count;
+                q.push({next_x, next_y, next_z, next_count});
+            }
+        }
+    }
+    cout << -1;
+}
+int main()
+{
+    cin.tie(0)->sync_with_stdio(false);
+    solve();
+    return 0;
+}

1600.cpp

@@ -0,0 +1,77 @@
+#include <iostream>
+#include <queue>
+#include <string>
+using namespace std;
+typedef long long ll;
+
+struct Node
+{
+    int x, y, z, day, count;
+};
+
+int xxxx[] = {-1, 0, 1, 0};
+int yyyy[] = {0, 1, 0, -1};
+
+void solve()
+{
+    int N, M, K;
+    cin >> N >> M >> K;
+    string map[N];
+    for (int i = 0; i < N; i++)
+        cin >> map[i];
+
+    int counts[N][M][K + 1][2];
+    for (int i = 0; i < N; i++)
+        for (int j = 0; j < M; j++)
+            for (int k = 0; k <= K; k++)
+                counts[i][j][k][0] = counts[i][j][k][1] = 1e9;
+
+    queue<Node> q;
+    q.push({0, 0, 0, 0, 1});
+    while (q.size())
+    {
+        auto [x, y, z, day, count] = q.front();
+        q.pop();
+
+        if (x == N - 1 && y == M - 1)
+        {
+            cout << count;
+            return;
+        }
+
+        for (int i = 0; i < 4; i++)
+        {
+            int next_x = x + xxxx[i];
+            int next_y = y + yyyy[i];
+            int next_z = z;
+            int next_count = count + 1;
+            int next_day = (day + 1) % 2;
+            if (next_x < 0 || next_y < 0 || next_x >= N || next_y >= M)
+                continue;
+            if (map[next_x][next_y] == '1')
+            {
+                if (next_day)
+                    next_z++;
+                else
+                {
+                    next_x -= xxxx[i];
+                    next_y -= yyyy[i];
+                }
+                if (next_z > K)
+                    continue;
+            }
+
+            if (counts[next_x][next_y][next_z][next_day] <= next_count)
+                continue;
+            counts[next_x][next_y][next_z][next_day] = next_count;
+            q.push({next_x, next_y, next_z, next_day, next_count});
+        }
+    }
+    cout << -1;
+}
+int main()
+{
+    cin.tie(0)->sync_with_stdio(false);
+    solve();
+    return 0;
+}

16933

@@ -0,0 +1,35 @@
+#include <iostream>
+using namespace std;
+typedef long long ll;
+
+bool is_prime[1000001];
+int main()
+{
+    cin.tie(0)->sync_with_stdio(false);
+    for (int i = 2; i <= 1000000; i++)
+        is_prime[i] = true;
+    for (int i = 2; i <= 1000000; i++)
+    {
+        if (is_prime[i])
+            for (int j = i + i; j <= 1000000; j += i)
+            {
+                is_prime[j] = false;
+            }
+    }
+
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        int z;
+        cin >> z;
+        int count = 0;
+        for (int i = 2; i < z; i++)
+        {
+            if (z - i >= i && is_prime[i] && is_prime[z - i])
+                count++;
+        }
+        cout << count << '\n';
+    }
+    return 0;
+}

16933.cpp

@@ -0,0 +1,94 @@
+#include <iostream>
+#include <queue>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+
+int arr[101][101], N;
+int xxxx[] = {-1, 0, 1, 0};
+int yyyy[] = {0, 1, 0, -1};
+int m = 2;
+void dfs(int x, int y)
+{
+    if (x < 0 || y < 0 || x >= N || y >= N || arr[x][y] != 1)
+        return;
+
+    arr[x][y] = m;
+    for (int i = 0; i < 4; i++)
+        dfs(x + xxxx[i], y + yyyy[i]);
+}
+
+struct Node
+{
+    int x, y, count;
+};
+
+void solve()
+{
+    cin >> N;
+    for (int i = 0; i < N; i++)
+        for (int j = 0; j < N; j++)
+            cin >> arr[i][j];
+
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+        {
+            if (arr[i][j] != 1)
+                continue;
+            dfs(i, j);
+            m++;
+        }
+    }
+
+    int result = 9999999;
+    for (int i = 2; i < m; i++)
+    {
+        int counts[N][N];
+        for (int j = 0; j < N; j++)
+            for (int k = 0; k < N; k++)
+                counts[j][k] = 9999999;
+
+        queue<Node> q;
+
+        for (int j = 0; j < N; j++)
+            for (int k = 0; k < N; k++)
+                if (arr[j][k] == i)
+                {
+                    counts[j][k] = 0;
+                    q.push({j, k, 0});
+                }
+
+        while (q.size())
+        {
+            auto [x, y, count] = q.front();
+            q.pop();
+
+            for (int i = 0; i < 4; i++)
+            {
+                int next_x = x + xxxx[i];
+                int next_y = y + yyyy[i];
+                int next_count = count + 1;
+
+                if (next_x < 0 || next_y < 0 || next_x >= N || next_y >= N || arr[next_x][next_y] == i || counts[next_x][next_y] <= next_count)
+                    continue;
+                if (arr[next_x][next_y] > 1)
+                {
+                    result = min(result, count);
+                    continue;
+                }
+
+                counts[next_x][next_y] = next_count;
+                q.push({next_x, next_y, next_count});
+            }
+        }
+    }
+
+    cout << result;
+}
+int main()
+{
+    cin.tie(0)->sync_with_stdio(false);
+    solve();
+    return 0;
+}

17071

@@ -0,0 +1,40 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+
+void solve()
+{
+    int N;
+    cin >> N;
+
+    int count = 0;
+    for (int i = 2; i <= 100000; i++)
+    {
+        if (N % i == 0)
+        {
+            count++;
+            N /= i;
+            i--;
+            continue;
+        }
+        else
+        {
+            if (count)
+            {
+                cout << i << ' ' << count << '\n';
+            }
+            count = 0;
+        }
+    }
+}
+
+int main()
+{
+    cin.tie(0)->sync_with_stdio(false);
+    int T;
+    cin >> T;
+    while (T--)
+        solve();
+    return 0;
+}

17103

@@ -0,0 +1,26 @@
+#include <iostream>
+#include <algorithm>
+using namespace std;
+typedef long long ll;
+
+int r = 0;
+bool solve()
+{
+    r++;
+    ll x, y, z;
+    cin >> x >> y >> z;
+    if (x + y + z == 0)
+        return false;
+
+    cout << "Case " << r << ": " << (z / y * x + min(z % y, x)) << '\n';
+
+    return true;
+}
+
+int main()
+{
+    cin.tie(0)->sync_with_stdio(false);
+    while (solve())
+        ;
+    return 0;
+}