fork(2) download
copy 
  1. /* package codechef; // don't place package name! */
  2.  
  3. import java.util.*;
  4. import java.lang.*;
  5. import java.io.*;
  6.  
  7. /* Name of the class has to be "Main" only if the class is public. */
  8. class Main
  9. {
  10.     static BufferedWriter put = new BufferedWriter(new OutputStreamWriter(System.out));
  11.     static int intmax = Integer.MAX_VALUE;
  12.     static int intmin = Integer.MIN_VALUE;
  13.     static long mod = 1000000007L;
  14.  
  15.     public static void main (String[] args) throws java.lang.Exception
  16. 	{
  17. 	    FastReader get = new FastReader();
  18.  
  19. 	    int T = get.nextInt();
  20.  
  21. 	    while(T-->0)
  22. 	    {
  23. 	    	int m=get.nextInt(), n=get.nextInt();
  24.  
  25. 	    	int [] X = new int[m-1];
  26. 	    	int [] Y = new int[n-1];
  27.  
  28. 	    	for(int i=0; i<m-1; i++) X[i]=get.nextInt();
  29. 	    	for(int i=0; i<n-1; i++) Y[i]=get.nextInt();
  30.  
  31. 	        ans( X, Y, m, n );
  32.  
  33. 	        put.flush();
  34. 	    }
  35.  
  36. 	    put.close();
  37. 	}
  38.  
  39. 	public static void ans( int[] X, int[] Y, int m, int n ) throws java.lang.Exception
  40. 	{
  41. 		ArrayList<Pair> pp = new ArrayList<>();
  42.  
  43.         for( int i=0; i<X.length; i++) pp.add(new Pair(X[i], 1));
  44.         for( int i=0; i<Y.length; i++) pp.add(new Pair(Y[i], 2));
  45.  
  46.         int v_cuts = 1, h_cuts =1;
  47.         long cost =0;
  48.  
  49.         Collections.sort(pp);
  50.  
  51.         for(int i=0; i<pp.size(); i++)
  52.         {
  53.             Pair p = pp.get(i);
  54.  
  55.             if(p.b == 2)
  56.             {
  57.                 cost += (long)p.a*v_cuts;
  58.                 h_cuts++;
  59.             }
  60.             else
  61.             {
  62.                 cost += (long)p.a*h_cuts;
  63.                 v_cuts++;
  64.             }
  65.         }
  66.  
  67.         put.write(cost+"\n");
  68. 	}
  69.  
  70. 	//
  71. 	// FUNCTIONS BELOW :
  72. 	// isPrime(), lcm(), gcd(), totient(), findDiv(), sortInt(), sortLong(),
  73. 	// power(), freqArr(), MATRIX: multiply(), power()
  74. 	// CLASSES BELOW :
  75. 	// DSU, FenwickTree, SegmentTree, LazySegTree, RangeBit, SparseTable, LCA, BitSet, MaxFlow
  76. 	//
  77.  
  78. 	public static int[] readArr(int N, FastReader get) throws Exception
  79.     {
  80.         int[] arr = new int[N];
  81.         StringTokenizer st = new StringTokenizer(get.nextLine(), " ");
  82.         for(int i=0; i < N; i++) arr[i] = Integer.parseInt(st.nextToken());
  83.  
  84.         return arr;
  85.     }
  86.  
  87.     public static long[] readArr2(int N, FastReader get) throws Exception
  88.     {
  89.         long[] arr = new long[N];
  90.         StringTokenizer st = new StringTokenizer(get.nextLine(), " ");
  91.         for(int i=0; i < N; i++) arr[i] = Long.parseLong(st.nextToken());
  92.  
  93.         return arr;
  94.     }
  95.  
  96.     public static int[][] readMat(int N, int M, FastReader get) throws Exception
  97.     {
  98.         int [][] mat = new int[N][M];
  99.  
  100.         for(int i=0; i < N; i++)
  101.         {
  102.             StringTokenizer st = new StringTokenizer(get.nextLine(), " ");
  103.             for(int j=0; j < M; j++) mat[i][j] = Integer.parseInt(st.nextToken());
  104.         }
  105.  
  106.         return mat;
  107.     }
  108.  
  109.     public static void print(int[] arr) throws java.lang.Exception
  110.     {
  111.         for(int x: arr)
  112.             put.write(x+" ");
  113.         put.write("\n");
  114.     }
  115.  
  116.     public static void printMat(int[][] arr) throws java.lang.Exception
  117.     {
  118.         for(int i=0; i < arr.length; i++)
  119.         {
  120.             for(int j=0; j < arr[0].length; j++)
  121.             {
  122.                 put.write(arr[i][j] + " ");
  123.             }
  124.             put.write("\n");
  125.         }
  126.         put.write("\n");
  127.     }
  128.  
  129.     public static boolean isPrime(long n)
  130.     {
  131.         if(n < 2) return false;
  132.         if(n == 2 || n == 3) return true;
  133.         if(n%2 == 0 || n%3 == 0) return false;
  134.         long sqrtN = (long)Math.sqrt(n)+1;
  135.         for(long i = 6L; i <= sqrtN; i += 6) {
  136.             if(n%(i-1) == 0 || n%(i+1) == 0) return false;
  137.         }
  138.         return true;
  139.     }
  140.  
  141.     public static long lcm(long a, long b)
  142.     {
  143.         return (a / gcd(a, b)) * b;
  144.     }
  145.  
  146.     public static long gcd(long a, long b)
  147.     {
  148.         if(a > b) a = (a+b)-(b=a);
  149.         if(a == 0L) return b;
  150.  
  151.         return gcd(b%a, a);
  152.     }
  153.  
  154.     public static long totient(long n)
  155.     {
  156.         long result = n;
  157.         for (int p = 2; p*p <= n; ++p)
  158.             if (n % p == 0)
  159.             {
  160.                 while(n%p == 0)
  161.                     n /= p;
  162.                 result -= result/p;
  163.             }
  164.         if (n > 1) result -= result/n;
  165.  
  166.         return result;
  167.     }
  168.  
  169.     public static ArrayList<Integer> findDiv(int N)
  170.     {
  171.         //gets all divisors of N
  172.         ArrayList<Integer> ls1 = new ArrayList<Integer>();
  173.         ArrayList<Integer> ls2 = new ArrayList<Integer>();
  174.         for(int i=1; i <= (int)(Math.sqrt(N)+0.00000001); i++)
  175.             if(N%i == 0)
  176.             {
  177.                 ls1.add(i);
  178.                 ls2.add(N/i);
  179.             }
  180.         Collections.reverse(ls2);
  181.         for(int b: ls2)
  182.             if(b != ls1.get(ls1.size()-1))
  183.                 ls1.add(b);
  184.         return ls1;
  185.     }
  186.  
  187.     public static void sortInt(int[] arr)
  188.     {
  189.         //because Arrays.sort() uses quicksort which is dumb
  190.         //Collections.sort() uses merge sort
  191.  
  192.         ArrayList<Integer> ls = new ArrayList<Integer>();
  193.  
  194.         for(int x: arr) ls.add(x);
  195.  
  196.         Collections.sort(ls);
  197.         for(int i=0; i < arr.length; i++) arr[i] = ls.get(i);
  198.     }
  199.  
  200.     public static void sortLong(long[] arr)
  201.     {
  202.         //because Arrays.sort() uses quicksort which is dumb
  203.         //Collections.sort() uses merge sort
  204.  
  205.         ArrayList<Long> ls = new ArrayList<Long>();
  206.  
  207.         for(long x: arr) ls.add(x);
  208.  
  209.         Collections.sort(ls);
  210.         for(int i=0; i < arr.length; i++) arr[i] = ls.get(i);
  211.     }
  212.  
  213.     public static void sortChar(char[] arr)
  214.     {
  215.         //because Arrays.sort() uses quicksort which is dumb
  216.         //Collections.sort() uses merge sort
  217.  
  218.         ArrayList<Character> ls = new ArrayList<Character>();
  219.  
  220.         for(char x: arr) ls.add(x);
  221.  
  222.         Collections.sort(ls);
  223.         for(int i=0; i < arr.length; i++) arr[i] = ls.get(i);
  224.     }
  225.  
  226.     public static String sortString(String inputString)
  227.     {
  228.         char tempArray[] = inputString.toCharArray();
  229.         sortChar(tempArray);
  230.         return new String(tempArray);
  231.     }
  232.  
  233.     public static long power(long x, long y, long p)
  234.     {
  235.         //0^0 = 1
  236.         long res = 1L;
  237.         x = x%p;
  238.         while(y > 0)
  239.         {
  240.             if((y&1)==1)
  241.                 res = (res*x)%p;
  242.             y >>= 1;
  243.             x = (x*x)%p;
  244.         }
  245.         return res;
  246.     }
  247.  
  248.     //custom multiset (replace with HashMap if needed)
  249.     public static void push(TreeMap<Integer, Integer> map, int k, int v)
  250.     {
  251.         //map[k] += v;
  252.         if(!map.containsKey(k)) map.put(k, v);
  253.         else map.put(k, map.get(k)+v);
  254.     }
  255.  
  256.     public static void pull(TreeMap<Integer, Integer> map, int k, int v)
  257.     {
  258.         //assumes map[k] >= v
  259.         //map[k] -= v
  260.         int lol = map.get(k);
  261.  
  262.         if(lol == v) map.remove(k);
  263.         else map.put(k, lol-v);
  264.     }
  265.  
  266.     public static HashMap<Integer, Integer> freqMap(int[] arr)
  267.     {
  268.         HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
  269.  
  270.         for(int x: arr)
  271.             if(!map.containsKey(x)) map.put(x, map.get(x) + 1);
  272.             else map.put(x, 1);
  273.  
  274.         return map;
  275.     }
  276.  
  277.     public static long[][] multiply(long[][] left, long[][] right)
  278.     {
  279.         long MOD = 1000000007L;
  280.         int N = left.length;
  281.         int M = right[0].length;
  282.         long[][] res = new long[N][M];
  283.         for(int a=0; a < N; a++)
  284.             for(int b=0; b < M; b++)
  285.                 for(int c=0; c < left[0].length; c++)
  286.                 {
  287.                     res[a][b] += (left[a][c]*right[c][b])%MOD;
  288.                     if(res[a][b] >= MOD)
  289.                         res[a][b] -= MOD;
  290.                 }
  291.         return res;
  292.     }
  293.  
  294.     public static long[][] power(long[][] grid, long pow)
  295.     {
  296.         long[][] res = new long[grid.length][grid[0].length];
  297.         for(int i=0; i < res.length; i++)
  298.             res[i][i] = 1L;
  299.         long[][] curr = grid.clone();
  300.         while(pow > 0)
  301.         {
  302.             if((pow&1L) == 1L)
  303.                 res = multiply(curr, res);
  304.             pow >>= 1;
  305.             curr = multiply(curr, curr);
  306.         }
  307.         return res;
  308.     }
  309. }
  310.  
  311. class Pair implements Comparable<Pair>
  312. {
  313.     int a, b;
  314.  
  315.     public Pair(int a, int b)
  316.     {
  317.         this.a = a;
  318.         this.b = b;
  319.     }
  320.  
  321.     @Override
  322.     public int compareTo(Pair p)
  323.     {
  324.     	if(this.a > p.a) return -1;
  325.         else if(this.a < p.a) return 1;
  326.         else
  327.         {
  328.             if(this.b > p.b) return -1;
  329.             else return 1;
  330.         }
  331.     }
  332. }
  333.  
  334. class DSU
  335. {
  336.     public int[] dsu;
  337.     public int[] size;
  338.  
  339.     public DSU(int N)
  340.     {
  341.         dsu = new int[N+1];
  342.         size = new int[N+1];
  343.         for(int i=0; i <= N; i++)
  344.         {
  345.             dsu[i] = i;
  346.             size[i] = 1;
  347.         }
  348.     }
  349.     //with path compression, no find by rank
  350.     public int find(int x)
  351.     {
  352.         return dsu[x] == x ? x : (dsu[x] = find(dsu[x]));
  353.     }
  354.     public void merge(int x, int y)
  355.     {
  356.         int fx = find(x);
  357.         int fy = find(y);
  358.         dsu[fx] = fy;
  359.     }
  360.     public void merge(int x, int y, boolean sized)
  361.     {
  362.         int fx = find(x);
  363.         int fy = find(y);
  364.         size[fy] += size[fx];
  365.         dsu[fx] = fy;
  366.     }
  367. }
  368.  
  369. class FenwickTree
  370. {
  371.     //Binary Indexed Tree
  372.     //1 indexed
  373.     public int[] tree;
  374.     public int size;
  375.  
  376.     public FenwickTree(int size)
  377.     {
  378.         this.size = size;
  379.         tree = new int[size+5];
  380.     }
  381.     public void add(int i, int v)
  382.     {
  383.         while(i <= size)
  384.         {
  385.             tree[i] += v;
  386.             i += i&-i;
  387.         }
  388.     }
  389.     public int find(int i)
  390.     {
  391.         int res = 0;
  392.         while(i >= 1)
  393.         {
  394.             res += tree[i];
  395.             i -= i&-i;
  396.         }
  397.         return res;
  398.     }
  399.     public int find(int l, int r)
  400.     {
  401.         return find(r)-find(l-1);
  402.     }
  403. }
  404.  
  405. class SegmentTree
  406. {
  407.     //Tlatoani's segment tree
  408.     //iterative implementation = low constant runtime factor
  409.     //range query, non lazy
  410.     final int[] val;
  411.     final int treeFrom;
  412.     final int length;
  413.  
  414.     public SegmentTree(int treeFrom, int treeTo)
  415.     {
  416.         this.treeFrom = treeFrom;
  417.         int length = treeTo - treeFrom + 1;
  418.         int l;
  419.         for (l = 0; (1 << l) < length; l++);
  420.         val = new int[1 << (l + 1)];
  421.         this.length = 1 << l;
  422.     }
  423.     public void update(int index, int delta)
  424.     {
  425.         //replaces value
  426.         int node = index - treeFrom + length;
  427.         val[node] = delta;
  428.         for (node >>= 1; node > 0; node >>= 1)
  429.             val[node] = comb(val[node << 1], val[(node << 1) + 1]);
  430.     }
  431.     public int query(int from, int to)
  432.     {
  433.         //inclusive bounds
  434.         if (to < from)
  435.             return 0; //0 or 1?
  436.         from += length - treeFrom;
  437.         to += length - treeFrom + 1;
  438.         //0 or 1?
  439.         int res = 0;
  440.         for (; from + (from & -from) <= to; from += from & -from)
  441.             res = comb(res, val[from / (from & -from)]);
  442.         for (; to - (to & -to) >= from; to -= to & -to)
  443.             res = comb(res, val[(to - (to & -to)) / (to & -to)]);
  444.         return res;
  445.     }
  446.     public int comb(int a, int b)
  447.     {
  448.         //change this
  449.         return Math.max(a,b);
  450.     }
  451. }
  452.  
  453. class LazySegTree
  454. {
  455.     //definitions
  456.     private int NULL = -1;
  457.     private int[] tree;
  458.     private int[] lazy;
  459.     private int length;
  460.  
  461.     public LazySegTree(int N)
  462.     {
  463.         length = N;   int b;
  464.         for(b=0; (1<<b) < length; b++);
  465.         tree = new int[1<<(b+1)];
  466.         lazy = new int[1<<(b+1)];
  467.     }
  468.     public int query(int left, int right)
  469.     {
  470.         //left and right are 0-indexed
  471.         return get(1, 0, length-1, left, right);
  472.     }
  473.     private int get(int v, int currL, int currR, int L, int R)
  474.     {
  475.         if(L > R)
  476.             return NULL;
  477.         if(L <= currL && currR <= R)
  478.             return tree[v];
  479.         propagate(v);
  480.         int mid = (currL+currR)/2;
  481.         return comb(get(v*2, currL, mid, L, Math.min(R, mid)),
  482.                 get(v*2+1, mid+1, currR, Math.max(L, mid+1), R));
  483.     }
  484.     public void update(int left, int right, int delta)
  485.     {
  486.         add(1, 0, length-1, left, right, delta);
  487.     }
  488.     private void add(int v, int currL, int currR, int L, int R, int delta)
  489.     {
  490.         if(L > R)
  491.             return;
  492.         if(currL == L && currR == R)
  493.         {
  494.             //exact covering
  495.             tree[v] += delta;
  496.             lazy[v] += delta;
  497.             return;
  498.         }
  499.         propagate(v);
  500.         int mid = (currL+currR)/2;
  501.         add(v*2, currL, mid, L, Math.min(R, mid), delta);
  502.         add(v*2+1, mid+1, currR, Math.max(L, mid+1), R, delta);
  503.         tree[v] = comb(tree[v*2], tree[v*2+1]);
  504.     }
  505.     private void propagate(int v)
  506.     {
  507.         //tree[v] already has lazy[v]
  508.         if(lazy[v] == 0)
  509.             return;
  510.         tree[v*2] += lazy[v];
  511.         lazy[v*2] += lazy[v];
  512.         tree[v*2+1] += lazy[v];
  513.         lazy[v*2+1] += lazy[v];
  514.         lazy[v] = 0;
  515.     }
  516.     private int comb(int a, int b)
  517.     {
  518.         return Math.max(a,b);
  519.     }
  520. }
  521.  
  522. class RangeBit
  523. {
  524.     //FenwickTree and RangeBit are faster than LazySegTree by constant factor
  525.     final int[] value;
  526.     final int[] weightedVal;
  527.  
  528.     public RangeBit(int treeTo)
  529.     {
  530.         value = new int[treeTo+2];
  531.         weightedVal = new int[treeTo+2];
  532.     }
  533.     private void updateHelper(int index, int delta)
  534.     {
  535.         int weightedDelta = index*delta;
  536.         for(int j = index; j < value.length; j += j & -j)
  537.         {
  538.             value[j] += delta;
  539.             weightedVal[j] += weightedDelta;
  540.         }
  541.     }
  542.     public void update(int from, int to, int delta)
  543.     {
  544.         updateHelper(from, delta);
  545.         updateHelper(to + 1, -delta);
  546.     }
  547.     private int query(int to)
  548.     {
  549.         int res = 0;
  550.         int weightedRes = 0;
  551.         for (int j = to; j > 0; j -= j & -j)
  552.         {
  553.             res += value[j];
  554.             weightedRes += weightedVal[j];
  555.         }
  556.         return ((to + 1)*res)-weightedRes;
  557.     }
  558.     public int query(int from, int to)
  559.     {
  560.         if (to < from)
  561.             return 0;
  562.         return query(to) - query(from - 1);
  563.     }
  564. }
  565.  
  566. class SparseTable
  567. {
  568.     public int[] log;
  569.     public int[][] table;
  570.     public int N;  public int K;
  571.  
  572.     public SparseTable(int N)
  573.     {
  574.         this.N = N;
  575.         log = new int[N+2];
  576.         K = Integer.numberOfTrailingZeros(Integer.highestOneBit(N));
  577.         table = new int[N][K+1];
  578.         sparsywarsy();
  579.     }
  580.     private void sparsywarsy()
  581.     {
  582.         log[1] = 0;
  583.         for(int i=2; i <= N+1; i++)
  584.             log[i] = log[i/2]+1;
  585.     }
  586.     public void lift(int[] arr)
  587.     {
  588.         int n = arr.length;
  589.         for(int i=0; i < n; i++)
  590.             table[i][0] = arr[i];
  591.         for(int j=1; j <= K; j++)
  592.             for(int i=0; i + (1 << j) <= n; i++)
  593.                 table[i][j] = Math.min(table[i][j-1], table[i+(1 << (j - 1))][j-1]);
  594.     }
  595.     public int query(int L, int R)
  596.     {
  597.         //inclusive, 1 indexed
  598.         L--;  R--;
  599.         int mexico = log[R-L+1];
  600.         return Math.min(table[L][mexico], table[R-(1 << mexico)+1][mexico]);
  601.     }
  602. }
  603.  
  604. class LCA
  605. {
  606.     public int N, root;
  607.     public ArrayDeque<Integer>[] edges;
  608.     private int[] enter;
  609.     private int[] exit;
  610.     private int LOG = 17; //change this
  611.     private int[][] dp;
  612.  
  613.     public LCA(int n, ArrayDeque<Integer>[] edges, int r)
  614.     {
  615.         N = n;   root = r;
  616.         enter = new int[N+1];
  617.         exit = new int[N+1];
  618.         dp = new int[N+1][LOG];
  619.         this.edges = edges;
  620.         int[] time = new int[1];
  621.         //change to iterative dfs if N is large
  622.         dfs(root, 0, time);
  623.         dp[root][0] = 1;
  624.         for(int b=1; b < LOG; b++)
  625.             for(int v=1; v <= N; v++)
  626.                 dp[v][b] = dp[dp[v][b-1]][b-1];
  627.     }
  628.     private void dfs(int curr, int par, int[] time)
  629.     {
  630.         dp[curr][0] = par;
  631.         enter[curr] = ++time[0];
  632.         for(int next: edges[curr])
  633.             if(next != par)
  634.                 dfs(next, curr, time);
  635.         exit[curr] = ++time[0];
  636.     }
  637.     public int lca(int x, int y)
  638.     {
  639.         if(isAnc(x, y))
  640.             return x;
  641.         if(isAnc(y, x))
  642.             return y;
  643.         int curr = x;
  644.         for(int b=LOG-1; b >= 0; b--)
  645.         {
  646.             int temp = dp[curr][b];
  647.             if(!isAnc(temp, y))
  648.                 curr = temp;
  649.         }
  650.         return dp[curr][0];
  651.     }
  652.     private boolean isAnc(int anc, int curr)
  653.     {
  654.         return enter[anc] <= enter[curr] && exit[anc] >= exit[curr];
  655.     }
  656. }
  657.  
  658. class BitSet
  659. {
  660.     private int CONS = 62; //safe
  661.     public long[] sets;
  662.     public int size;
  663.  
  664.     public BitSet(int N)
  665.     {
  666.         size = N;
  667.         if(N%CONS == 0)
  668.             sets = new long[N/CONS];
  669.         else
  670.             sets = new long[N/CONS+1];
  671.     }
  672.     public void add(int i)
  673.     {
  674.         int dex = i/CONS;
  675.         int thing = i%CONS;
  676.         sets[dex] |= (1L << thing);
  677.     }
  678.     public int and(BitSet oth)
  679.     {
  680.         int boof = Math.min(sets.length, oth.sets.length);
  681.         int res = 0;
  682.         for(int i=0; i < boof; i++)
  683.             res += Long.bitCount(sets[i] & oth.sets[i]);
  684.         return res;
  685.     }
  686.     public int xor(BitSet oth)
  687.     {
  688.         int boof = Math.min(sets.length, oth.sets.length);
  689.         int res = 0;
  690.         for(int i=0; i < boof; i++)
  691.             res += Long.bitCount(sets[i] ^ oth.sets[i]);
  692.         return res;
  693.     }
  694. }
  695.  
  696. class MaxFlow
  697. {
  698.     //Dinic with optimizations (see magic array in dfs function)
  699.     public int N, source, sink;
  700.     public ArrayList<Edge>[] edges;
  701.     private int[] depth;
  702.  
  703.     public MaxFlow(int n, int x, int y)
  704.     {
  705.         N = n;
  706.         source = x;
  707.         sink = y;
  708.         edges = new ArrayList[N+1];
  709.         for(int i=0; i <= N; i++)
  710.             edges[i] = new ArrayList<Edge>();
  711.         depth = new int[N+1];
  712.     }
  713.     public void addEdge(int from, int to, long cap)
  714.     {
  715.         Edge forward = new Edge(from, to, cap);
  716.         Edge backward = new Edge(to, from, 0L);
  717.         forward.residual = backward;
  718.         backward.residual = forward;
  719.         edges[from].add(forward);
  720.         edges[to].add(backward);
  721.     }
  722.     public long mfmc()
  723.     {
  724.         long res = 0L;
  725.         int[] magic = new int[N+1];
  726.         while(assignDepths())
  727.         {
  728.             long flow = dfs(source, Long.MAX_VALUE/2, magic);
  729.             while(flow > 0)
  730.             {
  731.                 res += flow;
  732.                 flow = dfs(source, Long.MAX_VALUE/2, magic);
  733.             }
  734.             magic = new int[N+1];
  735.         }
  736.         return res;
  737.     }
  738.     private boolean assignDepths()
  739.     {
  740.         Arrays.fill(depth, -69);
  741.         ArrayDeque<Integer> q = new ArrayDeque<Integer>();
  742.         q.add(source);
  743.         depth[source] = 0;
  744.         while(q.size() > 0)
  745.         {
  746.             int curr = q.poll();
  747.             for(Edge e: edges[curr])
  748.                 if(e.capacityLeft() > 0 && depth[e.to] == -69)
  749.                 {
  750.                     depth[e.to] = depth[curr]+1;
  751.                     q.add(e.to);
  752.                 }
  753.         }
  754.         return depth[sink] != -69;
  755.     }
  756.     private long dfs(int curr, long bottleneck, int[] magic)
  757.     {
  758.         if(curr == sink)
  759.             return bottleneck;
  760.         for(; magic[curr] < edges[curr].size(); magic[curr]++)
  761.         {
  762.             Edge e = edges[curr].get(magic[curr]);
  763.             if(e.capacityLeft() > 0 && depth[e.to]-depth[curr] == 1)
  764.             {
  765.                 long val = dfs(e.to, Math.min(bottleneck, e.capacityLeft()), magic);
  766.                 if(val > 0)
  767.                 {
  768.                     e.augment(val);
  769.                     return val;
  770.                 }
  771.             }
  772.         }
  773.         return 0L;  //no flow
  774.     }
  775.     private class Edge
  776.     {
  777.         public int from, to;
  778.         public long flow, capacity;
  779.         public Edge residual;
  780.  
  781.         public Edge(int f, int t, long cap)
  782.         {
  783.             from = f;
  784.             to = t;
  785.             capacity = cap;
  786.         }
  787.         public long capacityLeft()
  788.         {
  789.             return capacity-flow;
  790.         }
  791.         public void augment(long val)
  792.         {
  793.             flow += val;
  794.             residual.flow -= val;
  795.         }
  796.     }
  797. }
  798.  
  799. class FastReader
  800. {
  801.     BufferedReader br;
  802.     StringTokenizer st;
  803.  
  804.     public FastReader()
  805.     {
  806.         br = new BufferedReader(new InputStreamReader(System.in));
  807.     }
  808.  
  809.     String next()
  810.     {
  811.         while (st == null || !st.hasMoreElements())
  812.         {
  813.             try
  814.             {
  815.                 st = new StringTokenizer(br.readLine());
  816.             }
  817.             catch (IOException  e)
  818.             {
  819.                 e.printStackTrace();
  820.             }
  821.         }
  822.         return st.nextToken();
  823.     }
  824.  
  825.     int nextInt()
  826.     {
  827.         return Integer.parseInt(next());
  828.     }
  829.  
  830.     long nextLong()
  831.     {
  832.         return Long.parseLong(next());
  833.     }
  834.  
  835.     double nextDouble()
  836.     {
  837.         return Double.parseDouble(next());
  838.     }
  839.  
  840.     String nextLine()
  841.     {
  842.         String str = "";
  843.         try
  844.         {
  845.             str = br.readLine();
  846.         }
  847.         catch (IOException e)
  848.         {
  849.             e.printStackTrace();
  850.         }
  851.         return str;
  852.     }
  853. }
Runtime error #stdin #stdout #stderr 0.09s 49496KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
stderr
copy 
Exception in thread "main" java.lang.NullPointerException
	at java.base/java.util.StringTokenizer.<init>(StringTokenizer.java:199)
	at java.base/java.util.StringTokenizer.<init>(StringTokenizer.java:236)
	at FastReader.next(Main.java:815)
	at FastReader.nextInt(Main.java:827)
	at Main.main(Main.java:19)
https://ideone.com/yefbVc
problem CHOCOLA, based on SPOJ submission 30332827 (JAVA), 2022-10-31 13:20:23
language:
Java (HotSpot 12)
created:
1 year ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!