#include <iostream>
#include <vector>
using namespace std;
// 是個簡單的動態規劃就算了
// 怎么又是一道越界題目
// 以后統一不用long long改用 unsigned long long。更大。
int main(){vector<unsigned long long> dp(4,0);string str="";for(int i=1; i<=2023; ++i) str+=to_string(i);// 本題的解法是動態規劃for(char c : str){if(c=='2'){dp[0]++;dp[2]+=dp[1];}if(c=='0') dp[1]+=dp[0];if(c=='3') dp[3]+=dp[2];}cout<<dp[3]<<endl;return 0;
}

public class DpProblem {public static void main(String[] args) {// 創建一個長度為 4 的 long 類型數組 dp 并初始化為 0long[] dp = new long[4];// 拼接字符串StringBuilder str = new StringBuilder();for (int i = 1; i <= 2023; i++) {str.append(i);}// 動態規劃過程for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);if (c == '2') {dp[0]++;dp[2] += dp[1];}if (c == '0') {dp[1] += dp[0];}if (c == '3') {dp[3] += dp[2];}}// 輸出結果System.out.println(dp[3]);}
}    

#include <iostream>
#include <vector>
#define ll long long
using namespace std;const int N =  1e7 + 10;
vector<bool> vec(N, true); // 假設都是質數
vector<ll> res;
void sieve(){ // 歐拉篩vec[0]=vec[1]= false;for(int i=2; i<vec.size(); ++i){if(vec[i]) res.push_back((ll)i);for(ll num:res){if(num*i>vec.size()) break; // 超出最大范圍vec[i*num] = false;if(i%num==0) break; // 確保每個合數，只被最小因子除去。}}
}
//天吶，你要這樣玩？還咋玩？？
int main(){sieve();ll num = 0;for(ll i=0;i<res.size();i++){unsigned ll pp = res[i]*res[i];if(pp * pp >23333333333333) break;//一點小優化for(ll j=i+1;j<res.size();j++){ll qq = res[j]*res[j];if(pp*qq>23333333333333) break;if(pp*qq<2333) continue;num++;}}cout<<num<<endl;return 0;
}

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;public class PrimeNumberCombination {// 定義常量 N，用于篩法范圍static final int N = 10000010;// 標記每個數是否為質數的布爾數組static boolean[] isPrime = new boolean[N];// 存儲質數的列表static List<Integer> primes = new ArrayList<>();// 歐拉篩函數，篩選出所有質數public static void sieve() {// 初始化所有數為質數for (int i = 0; i < N; i++) {isPrime[i] = true;}// 0 和 1 不是質數isPrime[0] = isPrime[1] = false;for (int i = 2; i < N; i++) {if (isPrime[i]) {primes.add(i);}for (int prime : primes) {if (prime * i >= N) {break;}isPrime[prime * i] = false;if (i % prime == 0) {break;}}}}public static void main(String[] args) {// 調用歐拉篩函數sieve();BigInteger limit1 = BigInteger.valueOf(23333333333333L);BigInteger limit2 = BigInteger.valueOf(2333L);long num = 0;for (int i = 0; i < primes.size(); i++) {BigInteger pp = BigInteger.valueOf(primes.get(i)).pow(2);if (pp.pow(2).compareTo(limit1) > 0) {break;}for (int j = i + 1; j < primes.size(); j++) {BigInteger qq = BigInteger.valueOf(primes.get(j)).pow(2);BigInteger product = pp.multiply(qq);if (product.compareTo(limit1) > 0) {break;}if (product.compareTo(limit2) < 0) {continue;}num++;}}// 輸出滿足條件的組合數量System.out.println(num);}
}    

#include <iostream>
const int N = 1e5+5;
using namespace std;
int arr[N]; int main()
{int n;cin>>n;for(int i=0; i<n; ++i){int num;cin>>num;arr[num]++;}int num1=0, num2=0;for(int i : arr){if(i>2) num1 += i-2; // 求取數量相同的數在減2；else if(i==1) num2++;}int sum = 0;// 當已被占用的id的數量，大于未被占用id時，那么sum = num1;if(num1>num2){sum = num1;  }else{ // num2<num1的情況sum = num2 + (num1-num2)/2;}cout<<sum<<endl;return 0;
}

import java.util.Scanner;public class StudentIdAdjustment {// 定義常量 N，用于數組大小static final int N = 100005;public static void main(String[] args) {// 創建 Scanner 對象用于讀取輸入Scanner scanner = new Scanner(System.in);// 定義一個數組來記錄每個 ID 出現的次數int[] arr = new int[N];// 讀取學生的數量int n = scanner.nextInt();// 循環讀取每個學生的 ID，并統計每個 ID 出現的次數for (int i = 0; i < n; i++) {int num = scanner.nextInt();arr[num]++;}// 初始化兩個變量，用于統計需要處理的不同情況的數量int num1 = 0;int num2 = 0;// 遍歷數組，統計 num1 和 num2 的值for (int i : arr) {// 如果某個 ID 出現的次數大于 2，計算超出 2 的部分并累加到 num1if (i > 2) {num1 += i - 2;} // 如果某個 ID 只出現了 1 次，將 num2 加 1else if (i == 1) {num2++;}}// 初始化最終結果變量int sum = 0;// 當 num1 大于 num2 時，說明已被占用的 ID 數量更多，sum 等于 num1if (num1 > num2) {sum = num1;} // 當 num2 大于等于 num1 時，按照相應規則計算 sumelse {sum = num2 + (num1 - num2) / 2;}// 輸出最終結果System.out.println(sum);// 關閉 Scanner 對象，釋放資源scanner.close();}
}    

1 2 3 4
1 5 4
------------
對比兩個數列的第一位，相同，不用變
------------
3 3 4
6 4
第一位不同，合并小的前兩位
----------
6 4
6 4
....

#include <iostream>
#include <vector>
using namespace std;int main()
{int n,m;cin>>n>>m;vector<int> a(n,0);vector<int> b(m,0);for(int i=0; i<n; ++i) cin>>a[i];for(int i=0; i<m; ++i) cin>>b[i];// sum_a a數列的前綴和// sum_b b數列的前綴和// cnt_a a的位數// cnt_b b的位數// cnt_sum 總共需要的次數long long sum_a=0,sum_b=0,cnt_a=0,cnt_b=0,cnt_sum=0;while(true){if(sum_a==sum_b){sum_a+=a[cnt_a++];sum_b+=b[cnt_b++];}else if(sum_a<sum_b){ // 第一個值小，需要合并sum_a+=a[cnt_a++];cnt_sum++;}else if(sum_b<sum_a){ // 第二個值小，需要合并sum_b+=b[cnt_b++];cnt_sum++;}if(cnt_a==n&&cnt_b==m) break;}cout<<cnt_sum;return 0;
}

import java.util.Scanner;public class MergeArrays {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 讀取兩個數組的長度int n = scanner.nextInt();int m = scanner.nextInt();// 初始化兩個數組int[] a = new int[n];int[] b = new int[m];// 讀取第一個數組的元素for (int i = 0; i < n; i++) {a[i] = scanner.nextInt();}// 讀取第二個數組的元素for (int i = 0; i < m; i++) {b[i] = scanner.nextInt();}// 初始化前綴和變量和指針long sum_a = 0, sum_b = 0; // 使用long避免大數溢出int cnt_a = 0, cnt_b = 0; // 數組a和b的當前指針位置int cnt_sum = 0; // 記錄合并次數// 循環處理直到兩個數組都遍歷完畢while (true) {// 當兩個前綴和相等時，移動到下一個元素if (sum_a == sum_b) {// 注意邊界條件：避免數組越界if (cnt_a < n) {sum_a += a[cnt_a++]; // 移動a的指針并累加值}if (cnt_b < m) {sum_b += b[cnt_b++]; // 移動b的指針并累加值}} else if (sum_a < sum_b) {// a的前綴和較小，需要合并下一個元素sum_a += a[cnt_a++]; // 合并a的下一個元素cnt_sum++; // 合并次數加1} else {// b的前綴和較小，需要合并下一個元素sum_b += b[cnt_b++]; // 合并b的下一個元素cnt_sum++; // 合并次數加1}// 檢查是否已經遍歷完兩個數組的所有元素if (cnt_a == n && cnt_b == m) {break;}}// 輸出最終的合并次數System.out.println(cnt_sum);scanner.close();}
}

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;#define ll long long // 因為不可能出現負數，直接開到最大(unsigned long long)
const ll N = 2e3+5;struct point{int x;int y;
}p[N]; // 定義節點-預處理ll get_radius(int i, int j){ // 半徑的平方return (p[i].x-p[j].x)*(p[i].x-p[j].x) + (p[i].y-p[j].y)*(p[i].y-p[j].y);
}bool is_parallel(int i, int j, int k){ // 用叉乘的方法，快速判斷，這一步不會的，可以上網查詢叉乘的作用，以及用法。ll v = (p[j].x-p[i].x)*(p[k].y-p[i].y)-(p[j].y-p[i].y)*(p[k].x-p[i].x); // i-j(p[j].x-p[i].x),(p[j].y-p[i].y) 與 i-k(p[k].x-p[i].x),(p[k].y-p[i].y)if(v==0) return true;else return false;
}int main(){int n;cin>>n;for(int i=0; i<n; ++i) cin>>p[i].x>>p[i].y;vector<unordered_map<ll,vector<int>>> vec(n); // 存// 預處理，只需要耗時O(n^2)，即可分堆，避免3層暴力的大量重復計算for(int i=0; i<n; ++i){unordered_map<ll,vector<int>> m; // 用半徑的平方儲存，這樣就不用開方了for(int j=0; j<n; ++j){if(i==j) continue;ll len = get_radius(i,j);m[len].push_back(j); // 把這個點存進去}vec[i] = m; // 把map存入}// 最大的優點就是避免了許多無意義的重復計算int sum = 0;for(int i=0; i<n; ++i){ // 找到這個點，判斷其內部的存儲auto m = vec[i]; // 這個的出來的知識map結合，里面幼嫩多for(auto it=m.begin(); it!=m.end(); ++it){vector<int> p_m = it->second;if(p_m.size()<=1) continue; // 這種情況下，跳過for(int j=0; j<p_m.size(); ++j){for(int k=j+1; k<p_m.size(); ++k){if(is_parallel(i,p_m[j],p_m[k])) continue; // 共線sum++;}}}}cout<<sum<<endl;return 0;
}

import java.util.*;
public class Main {public static void main(String[] args) {//輸出部分//讀取輸入的點，并統計每個點的出現次數Scanner sc = new Scanner(System.in);int n = sc.nextInt();//輸入點的數量int[] x = new int [n + 10];//存儲每個點的x坐標int[] y = new int [n + 10];//存儲每個點的y坐標HashMap<String, Integer> s = new HashMap<>();//統計每個點的出現次數//鍵是點的坐標，如（"1 2")for(int i = 0; i < n; i++){x[i] = sc.nextInt();//輸入第i個點的x坐標y[i] = sc.nextInt();//輸入第i個點的y坐標String t = x[i] + " " + y[i];//將坐標拼接成字符串作為鍵s.put(t, s.getOrDefault(t , 0) + 1);//統計讀點的出現次數}//計算核心部分//對于每個點i，計算它與其他所有點j的距離，并將距離相同的點分組long res = 0;//最終結果for(int i = 0; i < n; i++){HashMap< Long,List<Integer> > map = new HashMap<>();//存儲距離相同的點的索引for(int j = 0; j < n; j++){if(i == j) continue;//跳過自己long d = (long)(Math.pow(x[i] - x[j], 2) + Math.pow(y[i] - y[j] , 2));//計算距離的平方List<Integer> list = map.getOrDefault(d, new ArrayList<>());//初始化列表list.add(j);//將點j加入對應的列表map.put(d,list);//更新map}//map是一個哈希表，鍵是距離的平方（d）值是一個列表，存儲所有與點i距離為d的點的索引//d是點i和點j之間的距離的平方（為了節省計算量，沒有開平方）for(long b : map.keySet()){List<Integer>list = map.get(b);//獲取距離為b的所有點res += (list.size() * (list.size() - 1)) /2;//統計點的數量long c = 0;for(int j : list){long x3 = 2 * x[i] - x[j], y3 = 2 * y[i] - y[j];//計算對稱帶點x與y的坐標if(s.containsKey(x3 + " " + y3)){//拼接成字符串c += s.get(x3 + " " + y3);//統計對稱點的出現次數}}res -= c/2;//減去重復統計的點對}}System.out.println(res);}
}

#include <iostream>
#include <cmath>
#include <vector>
#define ll long long
using namespace std;
const ll N = 1e6+5;
const ll maxn = 0x3f3f3f3f3f3f3f3f; // 定義“偽最大值”
ll n,m,sum_value=0,cnt=0,ans=maxn; // sum_value總和,cnt計數器vector<ll> dfn(N,0),low(N,0);
vector<int> vec[N]; // 定義鄰接表
vector<ll> value(N,0); // 每個節點的權值
vector<ll> node_sum(N,0); // 回退回來的節點總和void tarjan(int u, int fa){ // 現節點u、父節點fadfn[u]=low[u]=++cnt;for(int v:vec[u]){if(dfn[v]==0){   // 沒遍歷過tarjan(v,u);low[u] = min(low[v],low[u]);if(dfn[u]<low[v]) ans=min(ans,abs(sum_value-2*value[v]));value[u] += value[v];}else if(v!=fa){low[u]=min(low[u],low[v]);}}
}void slove(){ // 作為中轉站cin>>n>>m;for(int i=1; i<=n; ++i) cin>>value[i],sum_value+=value[i];for(int i=0; i<m; ++i){ // 將無向圖存入int r1,r2;cin>>r1>>r2;vec[r1].push_back(r2);vec[r2].push_back(r1);}// 現在啥都有了tarjan(1,0);if(value[1]!=sum_value) cout<<abs(sum_value-2*value[1])<<endl;else if(ans!=maxn) cout<<ans<<endl;else cout<<-1<<endl;
}int main(){slove();return 0;
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;public class Main {// 定義常量 N 作為數組大小static final long N = (long) (1e6 + 5);// 定義“偽最大值”static final long maxn = 0x3f3f3f3f3f3f3f3fL;// 節點數量 n，邊的數量 mstatic long n, m;// 所有節點權值總和static long sum_value = 0;// 時間戳計數器static long cnt = 0;// 存儲最終結果static long ans = maxn;// 存儲每個節點的發現時間戳static List<Long> dfn = new ArrayList<>();// 存儲每個節點能回溯到的最早祖先的發現時間戳static List<Long> low = new ArrayList<>();// 鄰接表，存儲圖的結構static List<List<Integer>> vec = new ArrayList<>();// 存儲每個節點的權值static List<Long> value = new ArrayList<>();// Tarjan 算法核心函數static void tarjan(int u, int fa) {// 初始化當前節點的發現時間戳和最早祖先時間戳dfn.set(u, ++cnt);low.set(u, cnt);// 遍歷當前節點的所有鄰接節點for (int v : vec.get(u)) {if (dfn.get(v) == 0) { // 如果鄰接節點未被訪問過// 遞歸調用 Tarjan 算法處理鄰接節點tarjan(v, u);// 更新當前節點的最早祖先時間戳low.set(u, Math.min(low.get(u), low.get(v)));// 如果當前節點的發現時間戳小于鄰接節點的最早祖先時間戳，說明該邊是割邊if (dfn.get(u) < low.get(v)) {ans = Math.min(ans, Math.abs(sum_value - 2 * value.get(v)));}// 將鄰接節點的權值累加到當前節點value.set(u, value.get(u) + value.get(v));} else if (v != fa) { // 如果鄰接節點已被訪問且不是父節點// 更新當前節點的最早祖先時間戳low.set(u, Math.min(low.get(u), low.get(v)));}}}// 主處理函數static void solve() {Scanner scanner = new Scanner(System.in);// 讀取節點數量和邊的數量n = scanner.nextLong();m = scanner.nextLong();// 初始化列表for (int i = 0; i <= n; i++) {dfn.add(0L);low.add(0L);value.add(0L);vec.add(new ArrayList<>());}// 讀取每個節點的權值并計算總和for (int i = 1; i <= n; i++) {value.set(i, scanner.nextLong());sum_value += value.get(i);}// 讀取邊的信息并構建鄰接表for (int i = 0; i < m; i++) {int r1 = scanner.nextInt();int r2 = scanner.nextInt();vec.get(r1).add(r2);vec.get(r2).add(r1);}// 從節點 1 開始進行 Tarjan 算法tarjan(1, 0);// 如果節點 1 的權值總和不等于所有節點的權值總和if (value.get(1) != sum_value) {System.out.println(Math.abs(sum_value - 2 * value.get(1)));} else if (ans != maxn) { // 如果找到了割邊System.out.println(ans);} else { // 沒有找到符合條件的割邊System.out.println(-1);}}public static void main(String[] args) {// 調用主處理函數solve();}
}

#include <iostream>
#include <queue>
using namespace std;const int N = 1e3+5;
const int step = 1e1+5;
struct node{int x;int y;int step;
};
int n,m,k;
queue<node> q; // 用隊列，實現廣搜
bool used[N][N][step]; // 預處理
int res[N][N][step]; // 表示，每個節點，都在那個狀態走過
char grid[N][N];int xf[]={1,-1,0,0}; // 用來記錄方向的改變
int yf[]={0,0,1,-1};int BFS(){q.push({0,0,0}); // 將第一個節點存入while(!q.empty()){node u = q.front(); q.pop(); // 取出該節點if(u.x==n-1 && u.y==m-1) return res[u.x][u.y][u.step];for(int i=0; i<4; ++i){int X = u.x+xf[i], Y = u.y+yf[i], st = u.step+1;if(X<0||X>=n||Y<0||Y>=m) continue; // 出邊界if(st<k&&grid[X][Y]!=grid[u.x][u.y]) continue;if(st==k&&grid[X][Y]==grid[u.x][u.y]) continue;st = st%k; // 時刻更新著if(used[X][Y][st]) continue; // 都是更新之后，在遍歷的used[X][Y][st]=true; // 表示遍歷過res[X][Y][st]=res[u.x][u.y][u.step]+1; // 多走了一步q.push({X,Y,st});}}return -1; // 此時還沒有解釋，只能說明一件事，遍歷到頭了，沒有結果。
}int main(){// 基本處理cin>>n>>m>>k;string str;for(int i=0; i<n; ++i){cin>>str;for(int j=0; j<m; ++j) grid[i][j]=str[j];}cout<<BFS();return 0;
}

import java.math.BigInteger;
import java.util.*;public class Main {static long INF = (long) 1e18;public static void main(String[] args) {Scanner sc = new Scanner(System.in); int n = sc.nextInt();int m = sc.nextInt();int k = sc.nextInt();sc.nextLine();char[][] mg = new char[n][m];for (int i = 0; i < n; i++) {mg[i] = sc.nextLine().toCharArray();}LinkedList<Pair> qu = new LinkedList<Pair>();qu.add(new Pair(0, 0, 1));int[][] d = new int[][] {{0,1},{1,0},{0,-1},{-1,0}};boolean[][][] visited = new boolean[n][m][2 * k];for (int step = 0; !qu.isEmpty(); step++) {int num = qu.size();for (int i = 0; i < num; i++) {Pair pair = qu.pollFirst();int px = pair.x, py = pair.y, pf = pair.flag;if (visited[px][py][pf]) {continue;}visited[px][py][pf] = true;if (pair.x == n - 1 && pair.y == m - 1) {System.out.print(step);return;}for (int j = 0; j < 4; j++) {int x = px + d[j][0];int y = py + d[j][1];int f = (pf + 1) % (2 * k);if (x >= 0 && x < n && y >= 0 && y < m) {if (visited[x][y][f]) {continue;}if (pf < k && mg[x][y] == 'A' || pf >= k && mg[x][y] == 'B') {qu.addLast(new Pair(x, y, f));}}}}}System.out.print(-1);}
}class Pair {int x, y, flag;public Pair(int x, int y, int flag) {super();this.x = x;this.y = y;this.flag = flag;}
}

#include <iostream>
#include <vector>
const int N = 2e6+5;
using namespace std;int main()
{int n,m;cin>>n>>m;vector<int> res(N,0);for(int i=0,r,l; i<n; ++i) cin>>l>>r,res[r+l]++; for(int i=1; i<N; ++i) res[i]+=res[i-1];for(int i=1,L,R; i<=m; ++i){cin>>L>>R;L*=2,R*=2;if(L==0) cout<<res[R]<<endl;else cout<<res[R]-res[L-1]<<endl;}return 0;
}

import java.util.Scanner;public class SegmentQuery {public static void main(String[] args) {// 定義常量 N，用于數組大小final int N = 2000005;Scanner scanner = new Scanner(System.in);// 讀取 n 和 m 的值int n = scanner.nextInt();int m = scanner.nextInt();// 創建長度為 N 的數組 res 并初始化為 0int[] res = new int[N];// 讀取 n 條線段的左右端點信息for (int i = 0; i < n; i++) {int l = scanner.nextInt();int r = scanner.nextInt();// 對線段中點對應的數組元素加 1res[l + r]++;}// 構建前綴和數組for (int i = 1; i < N; i++) {res[i] += res[i - 1];}// 處理 m 個查詢區間for (int i = 1; i <= m; i++) {int L = scanner.nextInt();int R = scanner.nextInt();// 將查詢區間的左右端點乘以 2L *= 2;R *= 2;int result;// 處理左端點為 0 的邊界情況if (L == 0) {result = res[R];} else {result = res[R] - res[L - 1];}// 輸出結果System.out.println(result);}scanner.close();}
}    

abs(a-b)<1e-6