int maxArray(vector<int>& nums, int left, int right, int& maxV){ if (left > right){ return INT_MIN; } int mid = left + (right - left) / 2; int lmax = maxArray(nums, left, mid-1, maxV); int rmax = maxArray(nums, mid+1, right, maxV); maxV = max(lmax, maxV); maxV = max(rmax, maxV); int lsum = 0; int mlmax = 0; for (int i = mid-1; i >= left; i--){ lsum += nums[i]; if (lsum > mlmax){ mlmax = lsum; } } int rsum = 0; int mrmax = 0; for (int i = mid+1; i <= right; i++){ rsum += nums[i]; if (rsum > mrmax){ mrmax = rsum; } } maxV = max(maxV, mlmax + mrmax + nums[mid]); return maxV; }
int maxArray(int *a, int size) { if (size < 0) { return MIN_INT; } return a[size-1] > maxArray(a, size-1) ? a[size-1] : maxArray(a, size-1); }
shared_ptr <JSONExport::JSONObject> serializeAccessor(JSONAccessor* accessor, void *context) { shared_ptr <JSONObject> accessorObject = shared_ptr<JSONObject>(new JSONObject()); accessorObject->setUnsignedInt32("byteStride", (unsigned int)accessor->getByteStride()); accessorObject->setUnsignedInt32("byteOffset", (unsigned int)accessor->getByteOffset()); accessorObject->setUnsignedInt32("elementsPerValue", (unsigned int)accessor->getElementsPerVertexAttribute()); accessorObject->setUnsignedInt32("count", (unsigned int)accessor->getCount()); accessorObject->setString("elementType", JSONUtils::getStringForType(accessor->getElementType())); JSONBuffer* buffer = context ? (JSONBuffer*)context : accessor->getBuffer().get(); accessorObject->setString("buffer", buffer->getID()); const double* min = accessor->getMin(); if (min) { shared_ptr <JSONExport::JSONArray> minArray(new JSONExport::JSONArray()); accessorObject->setValue("min", minArray); for (size_t i = 0 ; i < accessor->getElementsPerVertexAttribute() ; i++) { minArray->appendValue(shared_ptr <JSONExport::JSONNumber> (new JSONExport::JSONNumber(min[i]))); } } const double* max = accessor->getMax(); if (max) { shared_ptr <JSONExport::JSONArray> maxArray(new JSONExport::JSONArray()); accessorObject->setValue("max", maxArray); for (size_t i = 0 ; i < accessor->getElementsPerVertexAttribute() ; i++) { maxArray->appendValue(shared_ptr <JSONExport::JSONNumber> (new JSONExport::JSONNumber(max[i]))); } } return accessorObject; }
shared_ptr <GLTF::JSONObject> serializeMeshAttribute(GLTFMeshAttribute* meshAttribute, void *context) { shared_ptr <JSONObject> meshAttributeObject = shared_ptr<JSONObject>(new JSONObject()); meshAttributeObject->setUnsignedInt32("byteStride", (unsigned int)meshAttribute->getByteStride()); meshAttributeObject->setUnsignedInt32("byteOffset", (unsigned int)meshAttribute->getByteOffset()); meshAttributeObject->setUnsignedInt32("componentsPerAttribute", (unsigned int)meshAttribute->getElementsPerVertexAttribute()); meshAttributeObject->setUnsignedInt32("count", (unsigned int)meshAttribute->getCount()); meshAttributeObject->setString("componentType", GLTFUtils::getStringForGLType(meshAttribute->getComponentType())); void** buffers = (void**)context; GLTFBufferView *bufferView = context ? (GLTFBufferView*)buffers[0] : meshAttribute->getBufferView().get(); meshAttributeObject->setString("bufferView", bufferView->getID()); const double* min = meshAttribute->getMin(); if (min) { shared_ptr <GLTF::JSONArray> minArray(new GLTF::JSONArray()); meshAttributeObject->setValue("min", minArray); for (size_t i = 0 ; i < meshAttribute->getElementsPerVertexAttribute() ; i++) { minArray->appendValue(shared_ptr <GLTF::JSONNumber> (new GLTF::JSONNumber(min[i]))); } } const double* max = meshAttribute->getMax(); if (max) { shared_ptr <GLTF::JSONArray> maxArray(new GLTF::JSONArray()); meshAttributeObject->setValue("max", maxArray); for (size_t i = 0 ; i < meshAttribute->getElementsPerVertexAttribute() ; i++) { maxArray->appendValue(shared_ptr <GLTF::JSONNumber> (new GLTF::JSONNumber(max[i]))); } } return meshAttributeObject; }
int main(void) { int a[8]={4,7,3,6,8,1,9,2}; int result=maxArray(a, 8); printf("biggest int: %d\n", result); printf("18th number in Fibonacci sequence: %d", Fibonacci(18)); return 0; }
void Analysis::collect(const Mat& feature) { int nl = feature.rows; int nc = feature.cols; float max, min; pair<int, int> s; maxArray(feature, max, s); minArray(feature, min, s); printf("max: %f, min: %f\n", max, min, sum(feature)[0]); }
int maxArray(int A[], int left, int right, int& maxV) { //如果超过了,就返回INT_MIN,这样和别人比较的时候就没意义了 if(left>right) return INT_MIN; //左右中 int mid = (left+right)/2; int lmax = maxArray(A, left, mid -1, maxV); int rmax = maxArray(A, mid + 1, right, maxV); //maxV是左右最大的 maxV = max(maxV, lmax); maxV = max(maxV, rmax); //中间的左半部分,求最大 int sum = 0, mlmax = 0; for(int i= mid -1; i>=left; i--) { sum += A[i]; if(sum > mlmax) mlmax = sum; } //中间的右半部分,求最大 sum = 0; int mrmax = 0; for(int i = mid +1; i<=right; i++) { sum += A[i]; if(sum > mrmax) mrmax = sum; } //求左中右最大 maxV = max(maxV, mlmax + mrmax + A[mid]); return maxV; }
double* Color::getHSL() const { double max, min, c; double rgb[3], * hsl = new double[3]; for (int i = 0; i < 3; i++) rgb[i] = (double)color[i] / 255; max = maxArray(rgb, 3); min = minArray(rgb, 3); c = max - min; if (c == 0) hsl[0] = 0; else if (max == rgb[RGB_RED]) { hsl[0] = (rgb[RGB_GREEN] - rgb[RGB_BLUE]) / c; while (hsl[0] > 6) hsl[0] = hsl[0] - 6; } else if (max == rgb[RGB_GREEN]) hsl[0] = (rgb[RGB_BLUE] - rgb[RGB_RED]) / c + 2.0; else if (max == rgb[RGB_BLUE]) hsl[0] = (rgb[RGB_RED] - rgb[RGB_GREEN]) / c + 4.0; hsl[0] = 60 * hsl[0]; hsl[2] = (max + min) / 2; if (c == 0) hsl[1] = 0; /* this part does not work */ //else // hsl[1] = c / (1.0 - abs(2.0 * hsl[2] - 1.0)); else if (hsl[2] < .5) hsl[1] = c / (max + min); else hsl[1] = c / (2.0 - max - min); return hsl; }
void test2() { double s = maxArray(n, a); printf("maxArray=%lf\n", s); }
TTree* execute() { // q is simply a prefix for values which are a branch on the TTree TTree * dataTree = new TTree("treeData", "treeData"); float qChargeValues[7]; float qTotalCharge; float qMeasurementTimes[7]; float qCurrentValues[7]; float qVoltageValuesPreNoise[7]; float qVoltageValuesPostNoise[7]; int qDigitalReadoutValues[7]; float qFitShiftingTime; float qFitScalingFactor; int qTotalDigitalReadoutValue; int qDifferenceDigitalReadoutValue; float qIntegralReadoutValue; dataTree->Branch("qChargeValues", qChargeValues, "qChargeValues[7]/F"); dataTree->Branch("qTotalCharge", &qTotalCharge, "qTotalCharge/F"); dataTree->Branch("qMeasurementTimes", qMeasurementTimes, "qMeasurementTimes[7]/F"); dataTree->Branch("qCurrentValues", qCurrentValues, "qCurrentValues[7]/F"); dataTree->Branch("qVoltageValuesPreNoise", qVoltageValuesPreNoise, "qVoltageValuesPreNoise[7]/F"); dataTree->Branch("qVoltageValuesPostNoise", qVoltageValuesPostNoise, "qVoltageValuesPostNoise[7]/F"); dataTree->Branch("qDigitalReadoutValues", qDigitalReadoutValues, "qDigitalReadoutValues[7]/I"); dataTree->Branch("qFitShiftingTime", &qFitShiftingTime, "qFitShiftingTime/F"); dataTree->Branch("qFitScalingFactor", &qFitScalingFactor, "qFitScalingFactor/F"); dataTree->Branch("qTotalDigitalReadoutValue", &qTotalDigitalReadoutValue, "qTotalDigitalReadoutValue/I"); dataTree->Branch("qDifferenceDigitalReadoutValue", &qDifferenceDigitalReadoutValue, "qDifferenceDigitalReadoutValue/I"); dataTree->Branch("qIntegralReadoutValue", &qIntegralReadoutValue, "qIntegralReadoutValue/F"); const int numTrials = 10000; // Set number of trials const float shapingTime = 40.0; const float shapingPower = 1.0; ElectronSimulation * eSim = new ElectronSimulation(); for (int i = 0; i < numTrials; ++i) { TrialDataSet eSimData; eSim->simulate(eSimData, shapingTime, shapingPower); qTotalCharge = sumArray(eSimData.chargeValues, 7); qTotalDigitalReadoutValue = sumArray(eSimData.digitalReadoutValues, 7); qDifferenceDigitalReadoutValue = maxArray(eSimData.digitalReadoutValues, 7) - eSimData.digitalReadoutValues[0]; TF1 * fittedFunction = eSim->computeFunctionFit(eSimData); qFitShiftingTime = fittedFunction->GetParameter(0); qFitScalingFactor = fittedFunction->GetParameter(1); qIntegralReadoutValue = eSim->integrateFunc(qFitScalingFactor); fittedFunction->Draw(); for (int j = 0; j<7; ++j) { qChargeValues[j] = eSimData.chargeValues[j]; qMeasurementTimes[j] = eSimData.measurementTimes[j]; qCurrentValues[j] = eSimData.currentValues[j]; qVoltageValuesPreNoise[j] = eSimData.voltageValuesPreNoise[j]; qVoltageValuesPostNoise[j] = eSimData.voltageValuesPostNoise[j]; qDigitalReadoutValues[j] = eSimData.digitalReadoutValues[j]; } dataTree->Fill(); } return dataTree; }
int maxSubArray(int A[], int n) { // Start typing your C/C++ solution below // DO NOT write int main() function int maxV = INT_MIN; return maxArray(A, 0, n-1, maxV); }
int maxSubArray(vector<int>& nums) { int n = nums.size(); int maxV = INT_MIN; return maxArray(nums, 0, n-1, maxV); }