public int minimumPrice(long[] dread, int[] price) { int n = dread.length; int m = n << 1; long[] maximum = new long[m + 1]; Arrays.fill(maximum, 0); for (int i = 0; i < n; ++i) { long[] new_maximum = new long[m + 1]; Arrays.fill(new_maximum, -1); for (int j = 0; j <= m; ++j) { if (maximum[j] != -1) { if (maximum[j] >= dread[i]) { new_maximum[j] = Math.max(new_maximum[j], maximum[j]); } if (j + price[i] <= m) { new_maximum[j + price[i]] = Math.max(new_maximum[j + price[i]], maximum[j] + dread[i]); } } } maximum = new_maximum; } int answer = 0; while (maximum[answer] == -1) { answer++; } return answer; }
public static void main(String[] args) throws IOException { in = new Reader(); out = new PrintWriter(System.out, true); for (; ; ) { int n = in.nextInt(); if (n == 0) break; int[] arr1 = new int[n]; for (int i = 0; i < n; i++) arr1[i] = in.nextInt(); int m = in.nextInt(); int[] arr2 = new int[m]; for (int i = 0; i < m; i++) arr2[i] = in.nextInt(); int idx1 = 0, idx2 = 0, sum1 = 0, sum2 = 0, sum = 0; for (; ; ) { sum1 += arr1[idx1]; while (idx2 < m && arr1[idx1] > arr2[idx2]) sum2 += arr2[idx2++]; if (idx2 == m) { idx1++; break; } if (arr1[idx1] == arr2[idx2]) { sum2 += arr2[idx2++]; sum += Math.max(sum1, sum2); sum1 = sum2 = 0; } idx1++; if (idx1 == n) break; } while (idx1 < n) sum1 += arr1[idx1++]; while (idx2 < m) sum2 += arr2[idx2++]; sum += Math.max(sum1, sum2); out.println(sum); } }
public CatchExceptionTest( TestCase testCase, final boolean isVararg, final int argsCount, final int catchDrops) { this.testCase = testCase; this.dropped = catchDrops; if (Helper.IS_VERBOSE) { System.out.printf( "CatchException::CatchException(%s, isVararg=%b " + "argsCount=%d catchDrops=%d)%n", testCase, isVararg, argsCount, catchDrops); } MethodHandle thrower = testCase.thrower; int throwerLen = thrower.type().parameterCount(); List<Class<?>> classes; int extra = Math.max(0, argsCount - throwerLen); classes = getThrowerParams(isVararg, extra); this.argsCount = throwerLen + classes.size(); thrower = Helper.addTrailingArgs(thrower, this.argsCount, classes); if (isVararg && argsCount > throwerLen) { MethodType mt = thrower.type(); Class<?> lastParam = mt.parameterType(mt.parameterCount() - 1); thrower = thrower.asVarargsCollector(lastParam); } this.thrower = thrower; this.dropped = Math.min(this.argsCount, catchDrops); catcher = testCase.getCatcher(getCatcherParams()); nargs = Math.max(2, this.argsCount); }
public static int maxProduct(int[] A) { if (A.length == 0) { return 0; } if (A.length == 1 && A[0] < 0) { return A[0]; } int max_product = 0; int current_max = 0; int current_min = 0; int prev_max = 1; int prev_min = 1; for (int i = 0; i < A.length; i++) { current_max = Math.max(Math.max(prev_max * A[i], prev_min * A[i]), A[i]); current_min = Math.min(Math.min(prev_max * A[i], prev_max * A[i]), A[i]); max_product = Math.max(max_product, current_max); prev_max = current_max; prev_min = current_min; } return max_product; }
public void paint(Graphics gg) { int faceSize = Math.min(getWidth() - 4, getHeight() - 4); if (face == null) face = new PADFaceMapped( Math.max(2, (getWidth() - faceSize) / 2), Math.max(2, (getHeight() - faceSize) / 2), faceSize); if (buffer == null) { im = this.createImage(getWidth(), getHeight()); buffer = im.getGraphics(); } super.paint(buffer); buffer.setColor(new Color(255, 255, 255, 0)); buffer.fillRect(0, 0, im.getWidth(null), im.getHeight(null)); face.setDimensions( Math.max(2, (getWidth() - faceSize) / 2), Math.max(2, (getHeight() - faceSize) / 2), faceSize); face.paint(buffer); // draw buffer to screen gg.drawImage(im, 0, 0, null, null); }
public static void main(String[] args) { // TODO Auto-generated method stub Scanner in = new Scanner(System.in); int t = in.nextInt(); TreeMap<Long, Long> tmap = new TreeMap<>(); long res = 0; while (t-- > 0) { res = 0; int n = in.nextInt(); long m = in.nextLong(); tmap.clear(); long[] arr = new long[n]; res = in.nextLong(); arr[0] = res % m; res = Long.MIN_VALUE; tmap.put(arr[0], arr[0]); for (int i = 1; i < arr.length; i++) { arr[i] = in.nextLong(); arr[i] %= m; arr[i] += arr[i - 1]; arr[i] %= m; if (tmap.higherEntry(arr[i]) == null) { res = Math.max(res, arr[i]); tmap.put(arr[i], arr[i]); continue; } long val = tmap.higherEntry(arr[i]).getValue(); res = Math.max(res, (arr[i] - val + m) % m); tmap.put(arr[i], arr[i]); } System.out.println(res); } }
private Pair<MutableTextRange, StringBuffer> getFragmentByRange(int start, final int length) { final StringBuffer fragmentBuffer = new StringBuffer(); int end = start + length; // restoring buffer and remove all subfragments from the list int documentOffset = 0; int effectiveOffset = 0; Iterator<Pair<MutableTextRange, StringBuffer>> iterator = myAffectedFragments.iterator(); while (iterator.hasNext() && effectiveOffset <= end) { final Pair<MutableTextRange, StringBuffer> pair = iterator.next(); final MutableTextRange range = pair.getFirst(); final StringBuffer buffer = pair.getSecond(); int effectiveFragmentEnd = range.getStartOffset() + buffer.length(); if (range.getStartOffset() <= start && effectiveFragmentEnd >= end) return pair; if (effectiveFragmentEnd >= start) { final int effectiveStart = Math.max(effectiveOffset, start); if (range.getStartOffset() > start) { fragmentBuffer.append( myDocument.getCharsSequence(), effectiveStart - effectiveOffset + documentOffset, Math.min(range.getStartOffset(), end) - effectiveOffset + documentOffset); } if (end >= range.getStartOffset()) { fragmentBuffer.append(buffer); end = end > effectiveFragmentEnd ? end - (buffer.length() - range.getLength()) : range.getEndOffset(); effectiveFragmentEnd = range.getEndOffset(); start = Math.min(start, range.getStartOffset()); iterator.remove(); } } documentOffset += range.getEndOffset() - effectiveOffset; effectiveOffset = effectiveFragmentEnd; } if (effectiveOffset < end) { final int effectiveStart = Math.max(effectiveOffset, start); fragmentBuffer.append( myDocument.getCharsSequence(), effectiveStart - effectiveOffset + documentOffset, end - effectiveOffset + documentOffset); } MutableTextRange newRange = new MutableTextRange(start, end); final Pair<MutableTextRange, StringBuffer> pair = new Pair<MutableTextRange, StringBuffer>(newRange, fragmentBuffer); for (Pair<MutableTextRange, StringBuffer> affectedFragment : myAffectedFragments) { MutableTextRange range = affectedFragment.getFirst(); assert end <= range.getStartOffset() || range.getEndOffset() <= start : "Range :" + range + "; Added: " + newRange; } myAffectedFragments.add(pair); return pair; }
public static void main(String[] args) { FastScanner in = new FastScanner(System.in); int n = in.nextInt(); int[] s = new int[n + 5]; int[] s2 = new int[n + 5]; for (int i = 1; i <= n; i++) { s[i] = in.nextInt(); s2[n - i + 1] = s[i]; } int[] stack = new int[n + 5]; int size = 0; int answer = 0; for (int i = 1; i <= n; i++) { while (size > 0 && stack[size - 1] < s[i]) size--; stack[size++] = s[i]; if (size >= 2) answer = Math.max(answer, stack[size - 1] ^ stack[size - 2]); } size = 0; for (int i = 1; i <= n; i++) { while (size > 0 && stack[size - 1] < s2[i]) size--; stack[size++] = s2[i]; if (size >= 2) answer = Math.max(answer, stack[size - 1] ^ stack[size - 2]); } System.out.println(answer); }
public int filterRGB(int x, int y, int rgb) { int r = ((rgb >> 16) & 0xff); int g = ((rgb >> 8) & 0xff); int b = (rgb & 0xff); int gray = Math.max(Math.max(r, g), b); return (rgb & 0xff000000) | (gray << 16) | (gray << 8) | (gray << 0); }
/** * Calculates the min and max boundaries of the structure after it has been transformed into its * canonical orientation. */ private void calcBoundaries() { minBoundary.x = Double.MAX_VALUE; maxBoundary.x = Double.MIN_VALUE; minBoundary.y = Double.MAX_VALUE; maxBoundary.x = Double.MIN_VALUE; minBoundary.z = Double.MAX_VALUE; maxBoundary.z = Double.MIN_VALUE; xzRadiusMax = Double.MIN_VALUE; Point3d probe = new Point3d(); for (Point3d[] list : subunits.getTraces()) { for (Point3d p : list) { probe.set(p); transformationMatrix.transform(probe); minBoundary.x = Math.min(minBoundary.x, probe.x); maxBoundary.x = Math.max(maxBoundary.x, probe.x); minBoundary.y = Math.min(minBoundary.y, probe.y); maxBoundary.y = Math.max(maxBoundary.y, probe.y); minBoundary.z = Math.min(minBoundary.z, probe.z); maxBoundary.z = Math.max(maxBoundary.z, probe.z); xzRadiusMax = Math.max(xzRadiusMax, Math.sqrt(probe.x * probe.x + probe.z * probe.z)); } } // System.out.println("MinBoundary: " + minBoundary); // System.out.println("MaxBoundary: " + maxBoundary); // System.out.println("zxRadius: " + xzRadiusMax); }
public static void doIt() throws Exception { Scanner scanner = new Scanner(System.in); Integer currentBalance = scanner.nextInt(); int removeLast, removePenultimate; StringBuffer buf = new StringBuffer(); ArrayList<Character> chars = new ArrayList<Character>(); for (Character c : currentBalance.toString().toCharArray()) chars.add(c); ArrayList<Character> c1 = (ArrayList<Character>) chars.clone(); c1.remove(c1.size() - 1); for (Character cc : c1) buf.append(cc); removeLast = new Integer(buf.toString()); buf = new StringBuffer(); ArrayList<Character> c2 = (ArrayList<Character>) chars.clone(); c2.remove(c2.size() - 2); for (Character cc : c2) buf.append(cc); removePenultimate = new Integer(buf.toString()); System.out.println(Math.max(currentBalance, Math.max(removeLast, removePenultimate))); }
public Message(String message) { Vector indexes = new Vector(); int pos1 = message.indexOf(NMC_STATUS); if (pos1 != -1) { indexes.addElement(new Index(NMC_STATUS, pos1)); } int pos2 = message.indexOf(NMC_ERRTYPE); if (pos2 != -1) { indexes.addElement(new Index(NMC_ERRTYPE, pos2)); } int pos3 = message.indexOf(NMC_ERRINFO); if (pos3 != -1) { indexes.addElement(new Index(NMC_ERRINFO, pos3)); } int pos4 = message.indexOf(NMC_ERRDETAIL); if (pos4 != -1) { indexes.addElement(new Index(NMC_ERRDETAIL, pos4)); } int pos5 = message.indexOf(NMC_DESCRIPTION); if (pos5 != -1) { indexes.addElement(new Index(NMC_DESCRIPTION, pos5)); } int extraIndex = message.indexOf('\n', Math.max(Math.max(Math.max(pos1, pos2), Math.max(pos3, pos4)), pos5)); if (extraIndex != -1) { NMC_Extra = message.substring(extraIndex + 1, message.length()); /* temp solution until Yu-Jen can think up another header schema */ NMC_Extra = KeyCertUtility.replace(NMC_Extra, "Content-type: text/html", ""); } indexes.addElement(new Index(NMC_EXTRA, extraIndex + 1)); int size = indexes.size(); for (int i = 0; i < size - 1; i++) { Index beginIndex = (Index) (indexes.elementAt(i)); Index endIndex = (Index) (indexes.elementAt(i + 1)); if (beginIndex.getIndexValue().equals(NMC_STATUS)) { String val = message.substring(beginIndex.getPos() + NMC_STATUS.length(), endIndex.getPos()); NMC_Status = Integer.parseInt(val.trim()); } else if (beginIndex.getIndexValue().equals(NMC_DESCRIPTION)) { NMC_Description = message.substring(beginIndex.getPos() + NMC_DESCRIPTION.length(), endIndex.getPos()); } else if (beginIndex.getIndexValue().equals(NMC_ERRTYPE)) { NMC_ErrType = message.substring(beginIndex.getPos() + NMC_ERRTYPE.length(), endIndex.getPos()); } else if (beginIndex.getIndexValue().equals(NMC_ERRINFO)) { NMC_ErrInfo = message.substring(beginIndex.getPos() + NMC_ERRINFO.length(), endIndex.getPos()); } else if (beginIndex.getIndexValue().equals(NMC_ERRDETAIL)) { NMC_ErrDetail = message.substring(beginIndex.getPos() + NMC_ERRDETAIL.length(), endIndex.getPos()); } } }
public int getCount(int[] B, String operators) { long INF = 1L << 50; long min = 1; long max = INF; for (int i = 0; i < B.length; i++) { if (min > max) { break; } long mn = 0; long mx = 0; if (operators.charAt(i) == '-') { mn = Math.max(1, min - B[i]); mx = (max == INF) ? INF : max - B[i]; } else { mx = B[i] - min; mn = Math.max(B[i] - max, 1); } min = mn; max = mx; } if (max < min) { return 0; } if (max == INF) { return -1; } return (int) (max - min + 1); }
private float getFloorHeight() { float h00 = getHeight(); float h10 = getMap().getTile(this, 1, 0) != null ? getMap().getTile(this, 1, 0).getHeight() : 0; float h01 = getMap().getTile(this, 0, 1) != null ? getMap().getTile(this, 0, 1).getHeight() : 0; float h11 = getMap().getTile(this, 1, 1) != null ? getMap().getTile(this, 1, 1).getHeight() : 0; return Math.max(Math.max(h00, h10), Math.max(h01, h11)); }
/** * Get the bounding rectangle * * @return minimum bounding rectangle */ public BoundingRectangle2D getBounds() { if (boundsChanged == true) { boolean first = true; double minX = 0; double maxX = 0; double minY = 0; double maxY = 0; for (Enumeration e = vertices.elements(); e.hasMoreElements(); ) { Vector2D vertex = (Vector2D) e.nextElement(); if (first) { minX = vertex.getX(); maxX = vertex.getX(); minY = vertex.getY(); maxY = vertex.getY(); first = false; } else { minX = Math.min(minX, vertex.getX()); maxX = Math.max(maxX, vertex.getX()); minY = Math.min(minY, vertex.getY()); maxY = Math.max(maxY, vertex.getY()); } } bounds.set(minX, minY, Math.abs(maxX - minX), Math.abs(maxY - minY)); boundsChanged = false; } return bounds; }
/** * Assigns sequential identifiers to the provided <code>clusters</code> (and their sub-clusters). * If a cluster already has an identifier, the identifier will not be changed. * * @param clusters Clusters to assign identifiers to. * @throws IllegalArgumentException if the provided clusters contain non-unique identifiers */ public static void assignClusterIds(Collection<Cluster> clusters) { final ArrayList<Cluster> flattened = Lists.newArrayListWithExpectedSize(clusters.size()); flatten(flattened, clusters); synchronized (clusters) { final HashSet<Integer> ids = Sets.newHashSet(); // First, find the start value for the id and check uniqueness of the ids // already provided. int maxId = Integer.MIN_VALUE; for (final Cluster cluster : flattened) { if (cluster.id != null) { if (!ids.add(cluster.id)) { throw new IllegalArgumentException("Non-unique cluster id found: " + cluster.id); } maxId = Math.max(maxId, cluster.id); } } // We'd rather start with 0 maxId = Math.max(maxId, -1); // Assign missing ids for (final Cluster c : flattened) { if (c.id == null) { c.id = ++maxId; } } } }
// pretty print Matrix(2D array of doubles) public static String pprint(double[][] arr,DecimalFormat dformat) { int colDim = 0; for( double[] line : arr ) colDim = Math.max(colDim, line.length); StringBuilder sb = new StringBuilder(); int max_width = 0; int[] ilengths = new int[colDim]; Arrays.fill(ilengths, -1); for( double[] line : arr ) { for( int c = 0; c < line.length; ++c ) { double d = line[c]; String dStr = dformat.format(d); if( dStr.indexOf('.') == -1 ) dStr += ".0"; ilengths[c] = Math.max(ilengths[c], dStr.indexOf('.')); int prefix = (d >= 0 ? 1 : 2); max_width = Math.max(dStr.length() + prefix, max_width); } } for( double[] line : arr ) { for( int c = 0; c < line.length; ++c ) { double d = line[c]; String dStr = dformat.format(d); if( dStr.indexOf('.') == -1 ) dStr += ".0"; for( int x = dStr.indexOf('.'); x < ilengths[c] + 1; ++x ) sb.append(' '); sb.append(dStr); if( dStr.indexOf('.') == -1 ) sb.append('.'); for( int i = dStr.length() - Math.max(0, dStr.indexOf('.')); i <= 5; ++i ) sb.append('0'); } sb.append("\n"); } return sb.toString(); }
/** * Creates a mapping by merging two mappings. There must be no clashes. * * <p>Unlike {@link #append}, sources and targets are not shifted. * * <p>For example, <code>merge({0:0, 1:1}, {2:2, 3:3, 4:4})</code> yields <code> * {0:0, 1:1, 2:2, 3:3, 4:4}</code>. <code>merge({0:0, 1:1}, {1:2, 2:3})</code> throws, because * there are two entries with source=1. */ public static TargetMapping merge(TargetMapping mapping0, TargetMapping mapping1) { final int s0 = mapping0.getSourceCount(); final int s1 = mapping1.getSourceCount(); final int sMin = Math.min(s0, s1); final int sMax = Math.max(s0, s1); final int t0 = mapping0.getTargetCount(); final int t1 = mapping1.getTargetCount(); final int tMax = Math.max(t0, t1); final TargetMapping mapping = create(MappingType.INVERSE_SURJECTION, sMax, tMax); for (int s = 0; s < sMin; s++) { int t = mapping0.getTargetOpt(s); if (t >= 0) { mapping.set(s, t); assert mapping1.getTargetOpt(s) < 0; } else { t = mapping1.getTargetOpt(s); if (t >= 0) { mapping.set(s, t); } } } for (int s = sMin; s < sMax; s++) { int t = s < s0 ? mapping0.getTargetOpt(s) : -1; if (t >= 0) { mapping.set(s, t); assert mapping1.getTargetOpt(s) < 0; } else { t = s < s1 ? mapping1.getTargetOpt(s) : -1; if (t >= 0) { mapping.set(s, t); } } } return mapping; }
private void assertMatchEquals(List<Completion> res, String... expected) { String[] result = new String[res.size()]; for (int i = 0; i < res.size(); i++) { result[i] = res.get(i).toString(); } if (!Arrays.equals(stripScore(expected), stripScore(result))) { int colLen = Math.max(maxLen(expected), maxLen(result)); StringBuilder b = new StringBuilder(); String format = "%" + colLen + "s " + "%" + colLen + "s\n"; b.append(String.format(Locale.ROOT, format, "Expected", "Result")); for (int i = 0; i < Math.max(result.length, expected.length); i++) { b.append( String.format( Locale.ROOT, format, i < expected.length ? expected[i] : "--", i < result.length ? result[i] : "--")); } System.err.println(b.toString()); fail("Expected different output:\n" + b.toString()); } }
@BeforeClass public void setUp() { nonOverlappingExomeIntervals = new ArrayList<>(100); final Random rdn = new Random(13); // some "random" but fixed seed to make sure errors are deterministic. for (int i = 0; i < ExomeToolsTestUtils.REFERENCE_DICTIONARY.size(); i++) { int current = 0; final SAMSequenceRecord sequence = ExomeToolsTestUtils.REFERENCE_DICTIONARY.getSequence(i); while (current < sequence.getSequenceLength()) { int start = current + Math.max( minimumExonIntergapSize, (int) Math.round( rdn.nextGaussian() * sdExonIntergapSize + averageExonIntergapSize)); if (start >= sequence.getSequenceLength()) { break; } int size = Math.max( minimumExonSize, (int) Math.round(rdn.nextGaussian() * sdExonSize + averageExonSize)); int stop = start + size - 1; if (stop >= sequence.getSequenceLength()) { break; } nonOverlappingExomeIntervals.add( ExomeToolsTestUtils.createInterval(sequence.getSequenceName(), start, stop)); current = stop + 1; } } Collections.sort(nonOverlappingExomeIntervals, IntervalUtils.LEXICOGRAPHICAL_ORDER_COMPARATOR); exonDB = new HashedListTargetCollection<>(nonOverlappingExomeIntervals); }
public Object down(Message msg) { Address dest = msg.getDest(); boolean multicast = dest == null; if (msg.getSrc() == null) msg.setSrc(localAddress()); if (discard_all) { if (dest == null || dest.equals(localAddress())) loopback(msg); return null; } if (!multicast && drop_down_unicasts > 0) { drop_down_unicasts = Math.max(0, drop_down_unicasts - 1); return null; } if (multicast && drop_down_multicasts > 0) { drop_down_multicasts = Math.max(0, drop_down_multicasts - 1); return null; } if (down > 0) { double r = Math.random(); if (r < down) { if (excludeItself && dest != null && dest.equals(localAddress())) { if (log.isTraceEnabled()) log.trace("excluding itself"); } else { log.trace("dropping message"); num_down++; return null; } } } return down_prot.down(msg); }
/** ensure that non-Manual components of flow_tuple have equal dataRanges symmetric about 0.0 */ public static void equalizeFlow(Vector mapVector, DisplayTupleType flow_tuple) throws VisADException, RemoteException { double[] range = new double[2]; double low = Double.MAX_VALUE; double hi = -Double.MAX_VALUE; boolean anyAuto = false; Enumeration maps = mapVector.elements(); while (maps.hasMoreElements()) { ScalarMap map = ((ScalarMap) maps.nextElement()); DisplayRealType dtype = map.getDisplayScalar(); DisplayTupleType tuple = dtype.getTuple(); if (flow_tuple.equals(tuple) && !map.isManual && !map.badRange()) { anyAuto = true; low = Math.min(low, map.dataRange[0]); hi = Math.max(hi, map.dataRange[1]); } } if (!anyAuto) return; hi = Math.max(hi, -low); low = -hi; maps = mapVector.elements(); while (maps.hasMoreElements()) { ScalarMap map = ((ScalarMap) maps.nextElement()); DisplayRealType dtype = map.getDisplayScalar(); DisplayTupleType tuple = dtype.getTuple(); if (flow_tuple.equals(tuple) && !map.isManual && !map.badRange()) { map.setRange(null, low, hi, false); } } }
void run() { InputReader in = new InputReader(System.in); PrintWriter out = new PrintWriter(System.out); int n = in.nextInt(), q = in.nextInt(); int[] v = new int[n], c = new int[n]; for (int i = 0; i < n; ++i) v[i] = in.nextInt(); for (int i = 0; i < n; ++i) c[i] = in.nextInt(); for (int i = 0; i < q; ++i) { int a = in.nextInt(), b = in.nextInt(); long[] dp = new long[n + 1]; Node[] heap = new Node[2]; Arrays.fill(dp, -INF); for (int j = 0; j < 2; ++j) heap[j] = new Node(-INF, -1); for (int j = 0; j < n; ++j) { long val = v[j], maxv = val * b; int color = c[j]; maxv = Math.max(dp[color] + val * a, maxv); maxv = Math.max(choose(heap, color) + val * b, maxv); dp[color] = Math.max(maxv, dp[color]); update(heap, dp[color], color); } long ret = 0; for (int j = 1; j <= n; ++j) ret = Math.max(ret, dp[j]); out.println(ret); } out.close(); }
/** * Computes an allele biased version of the allele counts for a given pileup * * @param alleleCounts the allele counts for the original pileup * @param numReadsToRemove number of total reads to remove per allele * @return non-null array of new counts needed per allele */ protected static int[] runSmartDownsampling( final int[] alleleCounts, final int numReadsToRemove) { final int numAlleles = alleleCounts.length; int maxScore = scoreAlleleCounts(alleleCounts); int[] alleleCountsOfMax = alleleCounts; final int numReadsToRemovePerAllele = numReadsToRemove / 2; for (int i = 0; i < numAlleles; i++) { for (int j = i; j < numAlleles; j++) { final int[] newCounts = alleleCounts.clone(); // split these cases so we don't lose on the floor (since we divided by 2) if (i == j) { newCounts[i] = Math.max(0, newCounts[i] - numReadsToRemove); } else { newCounts[i] = Math.max(0, newCounts[i] - numReadsToRemovePerAllele); newCounts[j] = Math.max(0, newCounts[j] - numReadsToRemovePerAllele); } final int score = scoreAlleleCounts(newCounts); if (score < maxScore) { maxScore = score; alleleCountsOfMax = newCounts; } } } return alleleCountsOfMax; }
public static void main(String[] args) throws IOException { input.init(System.in); PrintWriter out = new PrintWriter(System.out); int depth = input.nextInt(); int n = (1 << (depth + 1)); int[] as = new int[n]; for (int i = 2; i < n; i++) as[i] = input.nextInt(); int[] paths = new int[n]; int max = 0; ArrayList<Integer>[] under = new ArrayList[n]; for (int i = 0; i < n; i++) under[i] = new ArrayList<Integer>(); for (int i = (1 << (depth)); i < n; i++) { int cur = i; while (cur > 1) { under[cur].add(i); paths[i] += as[cur]; cur /= 2; } max = Math.max(max, paths[i]); } int res = 0; for (int i = 2; i < n; i++) { int cm = 0; for (int x : under[i]) cm = Math.max(cm, paths[x]); int diff = max - cm; res += diff; for (int x : under[i]) paths[x] += diff; } out.println(res); out.close(); }
/** get the profiling results for "name" from this database. */ public ProfilerResults(ProfilerDB db, String name) { this.name = name; this.db = db; // XXX: if "name" is non existing, an empty data will be created ProfiledData data = db.getDataset(name); this.count = data.getSize(); this.memories = data.memories; this.ids = data.ids; this.times = data.times; this.current = -1; // calc min/max: min_times = Integer.MAX_VALUE; max_times = Integer.MIN_VALUE; min_mems = Long.MAX_VALUE; max_mems = Long.MIN_VALUE; for (int i = 0; i < count; i++) { min_mems = Math.min(min_mems, memories[i]); max_mems = Math.max(max_mems, memories[i]); min_times = Math.min(min_times, times[i]); max_times = Math.max(max_times, times[i]); } }
/** * Gets the maximum extent of this envelope across all three dimensions. * * @return the maximum extent of this envelope */ @Override public double maxExtent() { if (isNull()) { return 0.0; } return Math.max(getWidth(), Math.max(getHeight(), getDepth())); }
public ReRankCollector( int reRankDocs, int length, Query reRankQuery, double reRankWeight, SolrIndexSearcher.QueryCommand cmd, IndexSearcher searcher, Map<BytesRef, Integer> boostedPriority, boolean scale) throws IOException { super(null); this.reRankQuery = reRankQuery; this.reRankDocs = reRankDocs; this.length = length; this.boostedPriority = boostedPriority; this.scale = scale; Sort sort = cmd.getSort(); if (sort == null) { this.mainCollector = TopScoreDocCollector.create(Math.max(this.reRankDocs, length), true); } else { sort = sort.rewrite(searcher); this.mainCollector = TopFieldCollector.create( sort, Math.max(this.reRankDocs, length), false, true, true, true); } this.searcher = searcher; this.reRankWeight = reRankWeight; }
/*12. 求二叉树中节点的最大距离 具体分析(http://blog.csdn.net/lalor/article/details/7626678) 即二叉树中相距最远的两个节点之间的距离。 递归解法: (1)如果二叉树为空,返回0,同时记录左子树和右子树的深度,都为0 (2)如果二叉树不为空,最大距离要么是左子树中的最大距离,要么是右子树中的最大距离, 要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离, 同时记录左子树和右子树节点中到根节点的最大距离。 */ public static int getMaxDistance(TreeNode node, int maxLeft, int maxRight) { // maxLeft, 左子树中的节点距离左子树根节点的最远距离 // maxRight, 右子树中的节点距离左子树根节点的最远距离 if (node == null) { maxLeft = 0; maxRight = 0; return 0; } int maxLL = 0, maxLR = 0, maxRL = 0, maxRR = 0; int maxDistLeft, maxDistRight; if (node.left != null) { maxDistLeft = getMaxDistance(node.left, maxLL, maxLR); maxLeft = Math.max(maxLL, maxLR) + 1; } else { maxDistLeft = 0; maxLeft = 0; } if (node.right != null) { maxDistRight = getMaxDistance(node.right, maxRL, maxRR); maxRight = Math.max(maxRL, maxRR) + 1; } else { maxDistRight = 0; maxRight = 0; } int result = Math.max(Math.max(maxDistLeft, maxDistRight), maxLeft + maxRight + 1); return result; }
public int count( String[] s1000, String[] s100, String[] s10, String[] s1, String[] t1000, String[] t100, String[] t10, String[] t1) { String S1000 = concate(s1000); String S100 = concate(s100); String S10 = concate(s10); String S1 = concate(s1); String T1000 = concate(t1000); String T100 = concate(t100); String T10 = concate(t10); String T1 = concate(t1); int n = S1000.length(); Interval[] intervals = new Interval[n]; for (int i = 0; i < n; ++i) { intervals[i] = new Interval( Integer.parseInt( S1000.substring(i, i + 1) + S100.charAt(i) + S10.charAt(i) + S1.charAt(i)), Integer.parseInt( T1000.substring(i, i + 1) + T100.charAt(i) + T10.charAt(i) + T1.charAt(i))); } Arrays.sort(intervals); int leftmost = Integer.MAX_VALUE; int rightmost = Integer.MIN_VALUE; for (int i = 0; i < n; ++i) { leftmost = Math.min(leftmost, intervals[i].b); rightmost = Math.max(rightmost, intervals[i].a); } int answer = 0; for (int i = 0; i < n; ++i) { int total = 0; int now = leftmost; int j = 0; while (true) { if (intervals[i].a <= now) { now = Math.max(now, intervals[i].b); } if (now >= rightmost) { break; } int best = now; while (j < n && intervals[j].a <= now) { best = Math.max(best, intervals[j++].b); } if (best <= now) { return -1; } total++; now = best; } answer += total; } return answer; }