Merge pull request ashutosh97#141 from rishabhdeepsingh/fun

Added Chocolate Spoj Problem

Author: ashutosh97

Chocolate_SPOJ/question.txt

@@ -0,0 +1,41 @@
+We are given a bar of chocolate composed of m*n square pieces. One should break the chocolate into single squares. Parts of the chocolate may be broken along the vertical and horizontal lines as indicated by the broken lines in the picture.
+
+A single break of a part of the chocolate along a chosen vertical or horizontal line divides that part into two smaller ones. Each break of a part of the chocolate is charged a cost expressed by a positive integer. This cost does not depend on the size of the part that is being broken but only depends on the line the break goes along. Let us denote the costs of breaking along consecutive vertical lines with x1, x2, ..., xm-1 and along horizontal lines with y1, y2, ..., yn-1.
+
+The cost of breaking the whole bar into single squares is the sum of the successive breaks. One should compute the minimal cost of breaking the whole chocolate into single squares.
+
+
+For example, if we break the chocolate presented in the picture first along the horizontal lines, and next each obtained part along vertical lines then the cost of that breaking will be y1+y2+y3+4*(x1+x2+x3+x4+x5).
+
+Task
+Write a program that for each test case:
+
+Reads the numbers x1, x2, ..., xm-1 and y1, y2, ..., yn-1
+Computes the minimal cost of breaking the whole chocolate into single squares, writes the result.
+Input
+One integer in the first line, stating the number of test cases, followed by a blank line. There will be not more than 20 tests.
+
+For each test case, at the first line there are two positive integers m and n separated by a single space, 2 <= m,n <= 1000. In the successive m-1 lines there are numbers x1, x2, ..., xm-1, one per line, 1 <= xi <= 1000. In the successive n-1 lines there are numbers y1, y2, ..., yn-1, one per line, 1 <= yi <= 1000.
+
+The test cases will be separated by a single blank line.
+
+Output
+For each test case : write one integer - the minimal cost of breaking the whole chocolate into single squares.
+
+
+Example
+Input:
+1
+
+6 4
+2
+1
+3
+1
+4
+4
+1
+2
+
+Output:
+42

Chocolate_SPOJ/solution.java

@@ -0,0 +1,182 @@
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.io.BufferedWriter;
+import java.io.Writer;
+import java.io.OutputStreamWriter;
+import java.util.InputMismatchException;
+import java.io.IOException;
+import java.io.InputStream;
+ 
+/**
+ * Built using CHelper plug-in
+ * Actual solution is at the top
+ *
+ * @author Rishabhdeep Singh
+ */
+public class Main {
+    public static void main(String[] args) {
+        InputStream inputStream = System.in;
+        OutputStream outputStream = System.out;
+        InputReader in = new InputReader(inputStream);
+        OutputWriter out = new OutputWriter(outputStream);
+        MultipleTestcases solver = new MultipleTestcases();
+        int testCount = Integer.parseInt(in.next());
+        for (int i = 1; i <= testCount; i++)
+            solver.solve(i, in, out);
+        out.close();
+    }
+ 
+    static class MultipleTestcases {
+        public void solve(int testNumber, InputReader in, OutputWriter out) {
+            int n = in.nextInt();
+            int m = in.nextInt();
+            --n;
+            --m;
+            int[] x = in.nextIntArray(n);
+            int[] y = in.nextIntArray(m);
+            int s1 = 0, s2 = 0;
+            for (int i = 0; i < n; i++) {
+                s1 += x[i];
+            }
+            for (int i = 0; i < m; i++) {
+                s2 += y[i];
+            }
+            Arrays.sort(x);
+            Arrays.sort(y);
+            int ans = s1 + s2;
+            for (int i = n - 1, j = m - 1; i >= 0 && j >= 0; ) {
+                if (y[j] >= x[i]) {
+                    ans += s1;
+                    s2 -= y[j];
+                    --j;
+                } else {
+                    ans += s2;
+                    s1 -= x[i];
+                    --i;
+                }
+            }
+            out.println(ans);
+        }
+ 
+    }
+ 
+    static class OutputWriter {
+        private final PrintWriter writer;
+ 
+        public OutputWriter(OutputStream outputStream) {
+            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
+        }
+ 
+        public OutputWriter(Writer writer) {
+            this.writer = new PrintWriter(writer);
+        }
+ 
+        public void close() {
+            writer.close();
+        }
+ 
+        public void println(int i) {
+            writer.println(i);
+        }
+ 
+    }
+ 
+    static class InputReader {
+        private InputStream stream;
+        private byte[] buf = new byte[1024];
+        private int curChar;
+        private int numChars;
+        private InputReader.SpaceCharFilter filter;
+ 
+        public InputReader(InputStream stream) {
+            this.stream = stream;
+        }
+ 
+        public int read() {
+            if (numChars == -1) {
+                throw new InputMismatchException();
+            }
+            if (curChar >= numChars) {
+                curChar = 0;
+                try {
+                    numChars = stream.read(buf);
+                } catch (IOException e) {
+                    throw new InputMismatchException();
+                }
+                if (numChars <= 0) {
+                    return -1;
+                }
+            }
+            return buf[curChar++];
+        }
+ 
+        public int nextInt() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            int sgn = 1;
+            if (c == '-') {
+                sgn = -1;
+                c = read();
+            }
+            int res = 0;
+            do {
+                if (c < '0' || c > '9') {
+                    throw new InputMismatchException();
+                }
+                res *= 10;
+                res += c - '0';
+                c = read();
+            } while (!isSpaceChar(c));
+            return res * sgn;
+        }
+ 
+        public String nextString() {
+            int c = read();
+            while (isSpaceChar(c)) {
+                c = read();
+            }
+            StringBuilder res = new StringBuilder();
+            do {
+                if (Character.isValidCodePoint(c)) {
+                    res.appendCodePoint(c);
+                }
+                c = read();
+            } while (!isSpaceChar(c));
+            return res.toString();
+        }
+ 
+        public boolean isSpaceChar(int c) {
+            if (filter != null) {
+                return filter.isSpaceChar(c);
+            }
+            return isWhitespace(c);
+        }
+ 
+        public static boolean isWhitespace(int c) {
+            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
+        }
+ 
+        public String next() {
+            return nextString();
+        }
+ 
+        public int[] nextIntArray(int n) {
+            int[] array = new int[n];
+            for (int i = 0; i < n; ++i) array[i] = nextInt();
+            return array;
+        }
+ 
+        public interface SpaceCharFilter {
+            public boolean isSpaceChar(int ch);
+ 
+        }
+ 
+    }
+}
+