{"sys":{"type":"Array"},"total":2578,"skip":0,"limit":100,"items":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3AwvmovrZGbWL7ZreuE5GZ","type":"Entry","createdAt":"2026-04-02T14:49:46.770Z","updatedAt":"2026-04-02T14:49:46.770Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":113,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"How Topcoder AI Reviewer Works","slug":"how-topcoder-ai-reviewer-works","type":"Article","trackCategory":["Topcoder","Development"],"tags":["AI ","Review","Development"],"creationDate":"2026-04-01","readTime":"5 min","content":"__AI Reviewer is an Automated AI-powered quality gate for Topcoder challenge submissions using scorecard-driven evaluation.__\n\nIf you wish to understand more on how the AI Reviewers is affecting different roles such as members, copilots, reviewers, check out the [AI Reviewers Member Help Guide article](https://www.topcoder.com/thrive/articles/ai-reviewers-member-help-guide).\n\n### Overview\n\nThe TC-AI-Reviewer automates evaluation of Topcoder challenge submissions against structured scorecards. Built on the [Mastra](https://mastra.ai/) AI workflow framework, it provides:\n\n1. __Challenge Context Loading__ — Fetches/generates unified challenge context (requirements, tech stack, submission guidelines) via TC API \n2. __Workspace Analysis__ — Recursively scans submission files with intelligent exclusion patterns (node_modules, build artifacts, etc.) \n3. __Deterministic Pre-checks__ — Identifies empty files, hidden files, build artifacts, project markers, and validates patch files \n4. __Triage Gate__ — Fast rejection of fundamentally inadequate submissions (empty, tiny, missing manifests, invalid patches) \n5. __AI-Powered Audit__ — Skills-driven evaluation agent analyzes submissions against scorecard questions \n6. __Structured Output__ — Zod-validated answers with evidence citations, requirement mapping, and verdicts \n7. __Score Computation__ — Weighted scoring with answer-verdict consistency enforcement and coverage policies \n8. __TC API Integration__ — Posts results back to Topcoder platform with token usage metrics \n\n### Architecture\n\n#### High-level Flow\n![Architecture JSON](//images.ctfassets.net/piwi0eufbb2g/3UDWcwoskHHP2DQUVAuZUG/4702293ea6138032e40643f38bb7fe5c/Architecture_JSON.png)\n\n#### Workflows\n\n| Workflow | Description |\n|----------|------------|\n| `submissionQualityGateWorkflow` | Main orchestrator: file tree → pre-checks → triage → AI audit → scoring |\n| `submissionWorkspaceFileTreeWorkflow` | Recursively builds workspace file tree with content indexing |\n| `runPrecheckWorkflow` | Deterministic pre-checks + triage gate for fast rejection |\n\n#### Agent\n\nThe __Submission Auditor Agent__ (`submission-auditor-agent`) is a skills-driven AI agent that:\n\n- Loads challenge context from workspace files \n- Evaluates question applicability before scoring \n- Uses workspace tools (readFile, listFiles, searchFiles) to gather evidence \n- Produces structured JSON answers per scorecard question \n- Follows strict protocols for verdict consistency and evidence grounding \n\n### Skills Protocol\n\nThe agent uses a skills-driven evaluation protocol:\n\n1. `challenge-context-loading` — Load challenge requirements \n2. `question-applicability` — Determine if questions apply to this challenge \n3. `requirement-evaluation` — Ground evaluation in actual requirements \n4. `red-flag-detection` — Quick-reject checklist for critical issues \n5. `file-inspection` — Workspace file reading protocol \n6. `scale-scoring` — 1–5 rubric for SCALE questions \n7. `depth-analysis` — Implementation depth evaluation \n8. `scorecard-response` — Structured output format \n9. `strictness-enforcement` — Final self-check \n\n### Scorers\n\nBuilt-in evaluation scorers for quality assurance:\n\n| Scorer | Purpose |\n|--------|--------|\n| `answerRelevancyScorer` | Measures answer relevance to questions |\n| `promptAlignmentScorer` | Checks alignment with prompt instructions |\n| `toolCallAccuracyScorer` | Validates correct tool usage |\n| `hallucinationScorer` | Detects unsupported claims |\n| `scorecardCompletenessScorer` | Ensures all questions are answered |\n| `evidenceGroundingScorer` | Verifies evidence citations exist |\n| `verdictConsistencyScorer` | Checks answer-verdict alignment |\n| `skillProtocolComplianceScorer` | Validates protocol field population |\n\n### Required Environment Variables\n\n| Variable | Purpose |\n|----------|--------|\n| `AI_WORKFLOW_DETAILS_PATH` | Path to JSON file defining workflow + scorecard |\n| `CHALLENGE_ID` | Challenge identifier |\n| `WORKSPACE_PATH` | Path to workspace directory containing submission files |\n| `TC_API_BASE_URL` | Topcoder API base URL |\n| `TC_API_TOKEN` | Authentication token for TC API |\n| `SUBMISSION_ID` | (Optional) Submission identifier |\n| `TC_RUN_ID` | (Optional) Run ID for posting results back to TC API |\n| `LLM_PROVIDER_NAME` | (Optional) LLM provider: TC-Ollama or WiproAI (default) |\n| `LLM_MODEL_NAME` | (Optional) Model name (default: gpt-5-chat) |\n| `OLLAMA_HOST` | (Optional) Ollama base URL (default: http://127.0.0.1:11434) |\n| `OLLAMA_NUM_CTX` | (Optional) Override context window size (default: 32000) |\n| `LOCAL_DEV` | (Optional) Enable storage, observability, and scorers |\n| `WORKFLOW_RUN_TIMEOUT_MS` | (Optional) Workflow timeout (default: 900000ms / 15min) |\n\n### Example `.env`\n![Example AI Review](//images.ctfassets.net/piwi0eufbb2g/6TBPtzn3cyPmqkmWH29o6U/19c32fc426b3d93182c1c06c89338351/Example_AI_Review.png)\n\n### Scoring System\n\n#### Question Types\n\n| Type | Answer Field | Scoring |\n|------|-------------|--------|\n| __YES_NO__ | `yesNoAnswer: boolean` | true=100%, false=0% |\n| __SCALE__ | `scaleAnswer: number` | Normalized to 0–100% based on scaleMin/scaleMax |\n| __TEST_CASE__ | `testCasePass: boolean` | true=100%, false=0% |\n\n#### Weighted Score Formula\n![Score Formula](//images.ctfassets.net/piwi0eufbb2g/2ijrp3A2xEmTBtd1kL8IIY/50be38d9d5e455ee8e9f26d5a2455071/Score_Formula.png)\n\n#### Verdicts\n- `PASS` — Question criteria fully met \n- `FAIL` — Question criteria not met \n- `WARN` — Partial compliance or concerns \n- `N_A` — Question not applicable to this submission \n\n#### Post-Processing Policies\n\nThe scoring engine applies automatic corrections:\n\n1. __Answer-Verdict Consistency__ — Fixes contradictions (e.g., `yesNoAnswer=false` with verdict=`PASS`) \n2. __Evidence Coverage Policy__ — Hard-fail if <50% of content questions have grounded evidence \n3. __Requirement Mapping Consistency__ — Resolves conflicting status across questions \n4. __Implementation Depth Scrutiny__ — Adjusts high scores when evidence indicates shallow implementation \n\n### Output Artifact\n`quality-gate-report.json` structure:\n\n```\n{\n \"status\": \"success\",\n \"result\": {\n \"scorecardId\": \"...\",\n \"scorecardName\": \"...\",\n \"totalScore\": 87.32,\n \"maxScore\": 100,\n \"minimumPassingScore\": 75,\n \"passed\": true,\n \"overallVerdict\": \"PASS\",\n \"overallSummary\": \"...\",\n \"tokenUsage\": {\n \"calls\": [...],\n \"summary\": { \"inputTokens\": 0, \"outputTokens\": 0, \"totalTokens\": 0 }\n },\n \"preCheckSignals\": { ... },\n \"groups\": [\n {\n \"groupId\": \"...\",\n \"groupName\": \"...\",\n \"weight\": 100,\n \"score\": 87.32,\n \"sections\": [\n {\n \"sectionId\": \"...\",\n \"sectionName\": \"...\",\n \"weight\": 100,\n \"score\": 87.32,\n \"questionAnswers\": [\n {\n \"questionId\": \"UUID\",\n \"applicable\": true,\n \"verdict\": \"PASS\",\n \"evidence\": \"...\",\n \"reasoning\": \"...\",\n \"decision\": \"...\",\n \"yesNoAnswer\": true,\n \"fileInspections\": [...],\n \"requirementMapping\": [...],\n \"evidenceCitations\": [...]\n }\n ]\n }\n ]\n }\n ]\n }\n}\n```\n\n### Pre-check Signals\n- `totalFiles`, `totalDirectories`, `totalSizeBytes` \n- `emptyFiles` — Zero-byte files \n- `hiddenFiles` — Dotfiles and OS metadata \n- `buildArtifacts` — node_modules, dist, pycache, etc. \n- `projectMarkers` — package.json, pom.xml, requirements.txt, etc. \n- `extensionDistribution` — File type breakdown \n- `patchFiles` — Analysis of .patch/.diff files \n- `submissionTypeAnalysis` — Whether patch or full codebase is expected \n\n#### Triage Red Flags\n\n| Flag | Severity | Trigger |\n|------|----------|--------|\n| __EMPTY_SUBMISSION__ | critical | No files |\n| __NO_SOURCE_CODE__ | critical | No recognized source files |\n| __TINY_SUBMISSION__ | critical | <3 source files or <3KB |\n| __MOSTLY_BUILD_ARTIFACTS__ | critical | 80% files are build outputs |\n| __MISSING_NODE_MANIFEST__ | critical | Node.js required but no package.json |\n| __MISSING_PYTHON_MANIFEST__ | critical | Python required but no requirements.txt |\n| __MISSING_JVM_MANIFEST__ | critical | JVM required but no pom.xml/build.gradle |\n| __INVALID_PATCH_FORMAT__ | critical | Patch file not valid unified diff |\n| __TRIVIAL_PATCH__ | critical | Patch has <10 lines changed |\n| __PATCH_PLACEHOLDER_CONTENT__ | critical | Patch contains {...} or \"implement me\" |\n\n### Project Structure\n![Project Structure](//images.ctfassets.net/piwi0eufbb2g/b3bUqCYXdqQMsn5tRKMsV/7b8f5dafbeddc809c14f32dcdc11b859/Project_Structure.png)\n\n### Extending LLM Providers\n\n1. Add provider file in `src/utils/providers/` \n2. Implement the AI SDK interface with deterministic seeding support \n3. Export from `src/utils/providers/model-factory.ts` \n4. Add case to `createModel()` switch statement \n\n```\ncase 'MyProvider':\n return myProvider.chatModel(model);\n ```\n\n### Quick Start\n\n__Prerequisites__\n- Node.js ```>=``` 22.13.0 \n- pnpm ```>=``` 10.28.0 \n\n__Install Dependencies__\n`pnpm install`\n\n__Run Quality Gate__\n`pnpm start`\n\n__Development Server (Mastra Studio)__\n`pnpm dev\n#Then open http://localhost:3000/studio`\n\n__Check Results__\n`cat quality-gate-report.json | jq '.result | {score: .totalScore, verdict: .overallVerdict, passed: .passed}'\n`\n\n### Available Scripts\n\n| Script | Description |\n|--------|------------|\n| `pnpm start` | Run the quality gate workflow CLI |\n| `pnpm dev` | Start Mastra development server with hot reload |\n| `pnpm build` | Build the project |\n| `pnpm start:server` | Start Mastra production server |\n| `pnpm studio` | Open Mastra Studio UI |\n| `pnpm test` | Run scorer tests |\n| `pnpm test:scorers` | Run scorer tests (explicit) |\n| `pnpm lint` | Run ESLint |\n| `pnpm lint:fix` | Fix ESLint issues |\n| `pnpm format` | Format code with Prettier |\n| `pnpm format:check` | Check code formatting |\n\n### Logs\n\n```https://git.topcoder-dev.com/TC-AI-Workflows/TC-AI-Submission-Screener/actions/runs/{runId}```\n\n### Tech Stack\n- __Runtime:__ Node.js 22+ \n- __Framework:__ [Mastra](https://mastra.ai/) v1.13+ — AI workflow orchestration \n- __LLM Providers:__ Wipro AI SDK (default), TC-Ollama \n- __Storage:__ LibSQL (local development only) \n- __Validation:__ Zod v4 \n- __Observability:__ @mastra/observability (local development) \n- __Language:__ TypeScript 5.9+ ","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"7yO45g1yJfxerGOktJVufM","type":"Asset","createdAt":"2022-10-18T14:37:19.496Z","updatedAt":"2023-09-15T21:03:26.749Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":6,"revision":2,"locale":"en-US"},"fields":{"title":"Being a Successful Topcoder Freelancer","description":"","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/7yO45g1yJfxerGOktJVufM/a283509c9e75aeb72730662fb1bc989a/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner_Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"5EAFqYlQg1pHLvEHQ4yXFx","type":"Entry","createdAt":"2019-08-28T07:21:52.009Z","updatedAt":"2021-12-20T08:32:58.225Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":4,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Topcoder"}}],"openExternalLinksInNewTab":true}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"41l1dYBbokrTSUwfAOIo9Y","type":"Entry","createdAt":"2026-03-31T22:08:28.567Z","updatedAt":"2026-03-31T22:28:44.299Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":78,"revision":7,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"AI Reviewers – Member Help Guide","slug":"ai-reviewers-member-help-guide","type":"Article","trackCategory":["Topcoder"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3sofL39d1uWshUiu27kL21","type":"Entry","createdAt":"2019-10-24T21:25:43.778Z","updatedAt":"2019-10-24T21:25:43.778Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"Development","trackParent":"Topcoder"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"krziWcdrBi43HXkh0VYWr","type":"Entry","createdAt":"2019-08-27T06:12:20.665Z","updatedAt":"2019-08-27T06:12:20.665Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"Topcoder-Centric","trackParent":"Development"}}],"tags":["Ai","Review","Development"],"creationDate":"2026-03-31","readTime":"5 min","content":"### 1. Introduction\nWe are introducing AI Reviewers at Topcoder for development challenges. You can see them in the [Review App](https://review.topcoder.com/) for future challenges. If you are not familiar with the Review App, check out [this article](https://www.topcoder.com/thrive/articles/the-new-topcoder-review-flow).\n\nAI Reviewers introduce an automated pre-screening step into the challenge workflow, helping assess submissions early by providing scores, feedback, and quality signals. This enables competitors to improve their submissions during the submission phase and helps streamline what progresses to manual review.\n\nWhile AI influences the flow of submissions, __human oversight remains in place__ through reviewers and copilots, ensuring that decisions can be reviewed and adjusted where needed.\n\n### 2. What This Means for Each User\nAI Reviewers introduce new interactions across the challenge workflow.\nLet’s look at what this means for each user type.\n\n#### 2.1 For Competitors (Submitters)\nAfter you submit, your submission is queued for AI Review. Results are generated __shortly after submission__, though timing may vary depending on system load.\n\n__What You Will See__\n- AI Review __status__ (e.g., pending, completed)\n- Once completed:\n - __Aggregated Score__ (determines Pass / Fail)\n - __Pass / Fail status__\n - __Individual scores__ from one or more AI workflows\n - __Individual weights__ for each AI workflows\n - __Review dates__ for each AI workflows\n\n##### AI Review Summary View\n\n![review 1](//images.ctfassets.net/piwi0eufbb2g/3gdgNYz0DA9AePdL2uEhzr/321fe5b05a02974fcb8f658fabe55329/review_1.webp)\n\nIn the summary view, you can:\n- See the __aggregated score and final status (Pass/Fail)__\n- View scores from individual AI workflows\n- Hover over the __info icon next to the aggregated score__ to understand how it is calculated (it uses the weight of each AI workflow)\n\n__Some AI Workflows will be gated (marked with the thunder icon), meaning that if that review doesn’t pass minimum score, the entire submission will fail, regardless of the overall AI Workflow score. They are critical for your submission to pass review.__\n\n__Note__: You can only appeal to a submission that was failed by a human review, not by an AI Workflow. \n\n##### Detailed Feedback View\n\n![review 2](//images.ctfassets.net/piwi0eufbb2g/3XAE1cUX9REEog6UmTFk2A/93be1486e4926b59f10f18e6a4c6d842/review_2.webp)\n\nBy clicking on an __individual workflow score__, you can:\n- View __detailed feedback and comments__\n- Understand specific issues or improvement areas identified by that workflow\n\n__What You Should Do__\n- Review the AI feedback carefully\n- Use the insights to __improve your submission__\n\n__Important__\n- If your submission is marked as Fail, it will not move to the manual review phase (the standard review conducted by human reviewers).\n- However, you can __update and resubmit__ as long as the submission phase is still open\n- Even if your submission __Passes__, you can continue to refine and resubmit for a better outcome\n\n#### 2.2 For Reviewers\nDuring the review phase, AI Review results are available to help you prioritize and evaluate submissions.\n\n![review 3](//images.ctfassets.net/piwi0eufbb2g/5Dc2O1BMFuYhkoWVvjv4mh/965dc359cb996d3525180249a194f8cc/review_3.webp)\n\n__What You Will See__\n- Submissions that have __passed AI Review__ and are available for manual review\n- Submissions that are __locked__ due to failing AI Review and are not available for manual review\n- For each submission:\n - AI Review aggregated score and Pass/Fail status\n - AI workflow-level scores\n - Detailed AI feedback\n - \n\n#### Reviewing AI-Passed Submissions\n\nFor submissions that have passed AI Review:\n- You can proceed with normal manual evaluation\n- AI feedback is available to help guide your review\n\n__What You Should Do__\n- Use AI feedback as a starting point, not a conclusion\n- Perform a complete manual assessment\n- Assign scores based on your judgment\n\n__Important:__ Please evaluate each submission using your own expertise and judgment—without relying on external AI tools. You are fully responsible for ensuring the quality of the outcomes in this challenge.\n\n#### Handling Locked Submissions\n\n![review 4](//images.ctfassets.net/piwi0eufbb2g/yeatSNwOIZDcndLCA6tLP/587b1627fccef4c8d92216291bcd73c8/review_4.webp)\n\nSubmissions that fail AI Review are locked and do not move to manual review by default. However, as a reviewer, you can escalate a locked submission if you believe it deserves further evaluation.\n\n#### Escalation Flow\n\n![review 5](//images.ctfassets.net/piwi0eufbb2g/56ZYegbh2Af37Q0bWH2d8Z/f749b7cc514b7bac0842581877dac601/review_5.webp)\n\nFor locked submissions, you can initiate an escalation by clicking the __escalate icon next to the submission__.\n\nWhen you escalate a locked submission:\n\n- The request is sent to the copilot for review\n- The copilot will:\n - Approve → Submission is unlocked and becomes available for manual review\n - Reject → Submission remains locked\n\nIf a locked submission is __unlocked__, all reviewers are __notified via email__, ensuring it is picked up for manual evaluation.\n\n##### What You Should Do\n- Focus primarily on AI-passed submissions for evaluation\n- Review locked submissions selectively\n- Escalate only when:\n - The AI decision appears incorrect\n - The submission shows potential despite failing\n\n#### 2.3 For Copilots\n\nDuring the review phase, copilots have oversight of AI-reviewed submissions and control over which locked submissions can proceed to manual review.\n\n##### What You Will See\n![review 6](//images.ctfassets.net/piwi0eufbb2g/7pRntoLm2Pc1eOXHWbmy8J/68a198e5569982172c52018c823f0f05/review_6.webp)\n\n- Submissions that pass AI Review and human review\n- Submissions that are __locked__ due to failing AI Review\n- __Escalation requests__ raised by reviewers if any\n- For each submission:\n - AI Review aggregated score and Pass/Fail status\n - AI workflow-level scores\n - Detailed AI feedback (via drill-down)\n\n##### Reviewing Escalations\n\nEscalated submissions are indicated by a __verify icon next to the locked submission__.\n\n- Click the __verify icon__ to view the escalation request\n- Review the __submission details and AI feedback__\n\nWhen a reviewer escalates a locked submission, you can:\n\n- __Approve__ → Submission is __unlocked, and all the reviewers will get an email notification__ and then submission moves to manual review\n- __Reject__ → Submission remains locked\n\n![review 7](//images.ctfassets.net/piwi0eufbb2g/s8yUcdGpsc4ZlsgeR5chb/c140feedb4ded42449e584fd57b2e9d2/review_7.webp)\n\n##### Directly Unlocking Submissions\n\n![review 8](//images.ctfassets.net/piwi0eufbb2g/4q4EWQ7O0Ta66JwwXSygpz/3151490a73e2aa80d0a184b79c4de457/review_8.webp)\n\nIn addition to handling escalations, you can directly unlock submissions.\n\n- Click the __unlock icon next to a locked submission__ to unlock it\n- The submission will then move to the __manual review phase__\n\nThis allows you to act proactively if you identify submissions that should be reviewed further.\n\n##### What You Should Do\n- Review escalations carefully before approving\n- Use AI feedback as __supporting input__, not the sole decision factor\n\nUnlock submissions when:\n- The AI decision appears incorrect\n- The submission shows sufficient merit for manual evaluation\n\n__Important:__ Please evaluate each submission using your own expertise and judgment - without relying on external AI tools.","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"7yO45g1yJfxerGOktJVufM","type":"Asset","createdAt":"2022-10-18T14:37:19.496Z","updatedAt":"2023-09-15T21:03:26.749Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":6,"revision":2,"locale":"en-US"},"fields":{"title":"Being a Successful Topcoder Freelancer","description":"","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/7yO45g1yJfxerGOktJVufM/a283509c9e75aeb72730662fb1bc989a/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner_Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"5EAFqYlQg1pHLvEHQ4yXFx","type":"Entry","createdAt":"2019-08-28T07:21:52.009Z","updatedAt":"2021-12-20T08:32:58.225Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":4,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Topcoder"}}],"openExternalLinksInNewTab":true}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"555vJGIKA2wfhZRTLl39Pt","type":"Entry","createdAt":"2020-04-20T12:41:38.832Z","updatedAt":"2026-03-18T00:28:23.594Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":53,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 716","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Java"],"creationDate":"2017-07-10T00:00:00.000Z","readTime":"20 min","content":"# Single Round Match 716 Editorials\n\nSRM 716 Editorials are now published. We are still awaiting the submission to the Div I Hard problem. Thanks to [survival07](https://profiles.topcoder.com/survival07), [Vetteru](https://profiles.topcoder.com/Vetteru) and [Shizhouxing](https://profiles.topcoder.com/Shizhouxing) for contributing to the SRM 716 Editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## Permutiple\nSRM 716 Round 1 - Division II, Level One \n- by [survival07](https://profiles.topcoder.com/survival07)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14628)\n\nTuhin07\nProblem statement: Rearrange the digits of a number (x) without leading zeros such that new number y is a multiple of x and x != y. Check whether it’s possible.\nMathematical form of y = x * C. What is the range of C here. It can’t be 1. In that case y would become equal to x. C can’t be 10 as it would add an extra digit ‘0’ to x. So range of C is [2, 3, …, 9]\nSo the idea is to multiply x by all possible values of C one at a time and then check if the product y has the same number of counts for each digit (0-9) as x.\nAnother idea would be generating all possible permutations for digits of x and then check if any permutation is a multiple of x. In that case it needs to ensure that permutation doesn’t have leading zeros.\n\nHere is the C++ code:\n\n```\n[cpp]\n\nclass Permutiple {\npublic:\nstring isPossible(int x) {\nstring p = \"Possible\";\nstring imp = \"Impossible\";\nint i,j;\n//count_x[i] is the counter number for digit i in number x\nint count_x[10];\nint a = x;\nmemset((count_x),(0),sizeof(count_x)); //initialize x's counter array to zero's\nwhile(a){\ncount_x[a%10]++;\na /= 10;\n}\nforl(i,2,10){\nint y = x*i;\n//count_y[i] is the counter number for digit i in number y\nint count_y[10];\nmemset((count_y),(0),sizeof(count_y)); //initialize array to zero's\nwhile(y){\ncount_y[y%10]++;\ny /= 10;\n}\nbool ok=true;\nforl(j,0,10){\nif(count_x[j] != count_y[j]){ //check if digit j has equal counter in both x and y\nok=false;\nbreak;\n}\n}\nif(ok) //return 'Possible' if both counter arrays are same\nreturn p;\n}\nreturn imp; //Otherwise 'Impossible'\n}\n};\n\n[/cpp]\n```\n\n## ConstructLCSEasy\nSRM 716 Round 1 - Division II, Level Two \n- by [survival07](https://profiles.topcoder.com/survival07)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14624)\n\nTuhin07\nImportant constraint in this problem is: ab ≤ bc ≤ ca\nIf the LCS length of two strings A and B is x, then the length of both A and B is at least x. Because LCS can’t be larger than the smallest (based on length) input string. Let’s denote length of string A as L(A).\n\nSo, from parameter ab we can say: L(A), L(B) ≥ ab\nFrom parameter bc: L(B), L(C) ≥ bc\nFrom parameter ca: L(A), L(C) ≥ ca\n\nHere is the thing – if a variable x is greater than or equal to both y and z and y ≥ z, we can definitely draw a conclusion that x ≥ y. No need to consider z.\nConsidering the above constraints on L(A) we see L(A) ≥ ca and ab. But ca ≥ ab. So L(A) must be greater than or equal to ca. Similarly, L(B) ≥ bc and L(C) ≥ ca. From these derived constraints it’s quite intuitive to build strings A, B and C. Following picture will illustrate the process of building strings.\n\n![SRM716 1](//images.ctfassets.net/piwi0eufbb2g/7AdIBuWb5vlb8HYVko9wGF/fabdb146b6e1a25b792f258739770f8d/SRM716_1.webp)\nHere we see that f(A,B) [LCS of A and B] = ab as there are ab 1’s in B and ab ≤ ca.\nF(B,C) = bc because string C includes B and L(B) = bc. Number of 1’s in C = ab+ (ca-ab) = ca which makes f(C,A) = ca. Simultaneously swapping all 1’s to 0’s and all 0’s to 1’s in string A, B and C will build a different solution. Here is the C++ code:\n\n```\n[cpp]\n\nclass ConstructLCSEasy {\npublic:\nstring construct(int ab, int bc, int ca) {\nstring A = string(ca,'1');\nstring B = string(ab,'1') + string(bc-ab,'0');\nstring C = B + string(ca-ab, '1');\nreturn A + \" \" + B + \" \" + C;\n}\n};\n\n[/cpp]\n``` \n\n## JumpDistancesOnTreeEasy\nSRM 716 Round 1 - Division II, Level Three \n-by [Vetteru](https://profiles.topcoder.com/Vetteru)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14626)\n\nThe solution of this problem consists of 3 parts such as initialize, evaluate and update.\nIn initialize section (void init(int[] p) in my code), we have to initialize some variable and calculate minimum distances of all pairs.\n\nTo calculate minimum distances, I used Warshall–Floyd Algorithm.\nIn evaluate section (boolean next(int dist) in my code), we have to evaluate the next step is possible or impossible.\nIf a node that is S[i] (i = current index) distance away from reachable nodes exists, the step is possible. otherwise, impossible.\nIn update section (void update(int dist) in my code), we have to update reachable nodes.\nNew reachable node is a node that is n distance (any combination of previous used distances) away from current reachable nodes.\n\nExample of the solution:\ndistance set S = [2, 4]\n\n![SRM716 2](//images.ctfassets.net/piwi0eufbb2g/zT858AekBYzZ7eDLPckzB/54499ccbbfc409f360a155292476f77c/SRM716_2.webp)\n\ninitialize : Initialize variables and calculate distance of all pairs.\nevaluation : First, we are at '0' and a given distance is 2. We can reach '3' and '4'. So the evaluation returns possible.\n\nupdate : Current reachable node is only '0'. So we add all nodes that distance is multiple of 2.\nNote that given distance is a form of set, so we can use that distances many times.\nIn this time '3', '4' (distance : 2), '6' (distance : 4) are reachable.\nSo at the end of this section, reachable nodes will be ['0', '3', '4', '6'].\nevaluation : In this time, we can be at ['0', '3', '4', '6'] and a given distance is 4.\n'0' is 4 distance away from '6'. So this evaluation also returns possible.\nupdate : In this update section, No new reachable nodes found.\nfinish : Every queries are done correctly and the answer is \"POSSIBLE\".\n\n__Complexity__:\nn := the number of vertexes\ns := the size of set of distances\ninitialize : Time - O(n^3), Space - O(n^2)\n- Warshall–Floyd Algorithm's cost\n- initialize 2D array that hold all distances of all paris.\nevaluate : Time - O(n^2), Space - O(1)\n- In worst case, we have to check all distances of all pairs.\n- No memory required.\nupdate : Time - O(n^2), Space - O(n)\n- In worst case, we have to check all distances of all pairs.\n- Need a list that hold reachable nodes.\ntotal : Time - O(n^3) or O(s x n^2), Space - O(n^2)\n- We call initialize only one time, evaluate s times, and update s times.\nIn this problem, s and n is same size (1 <= s, n <= 50). So the time complexity is O(n^3) or O(s x n^2).\n- Space complexity is O(n^2). A 2D array that hold all distances of all paris is that.\n\n```\n[java]\n\nimport java.util.HashSet;\nimport java.util.Set;\npublic class JumpDistancesOnTreeEasy {\nprivate static final int INF = 1<<25;\nprivate int size;\nprivate int[][] distances;\nprivate Set selectableDist;\nprivate Set selectableNode;\npublic String isPossible(int[] p, int[] S) {\ninit(p);\nfor (int s : S) {\nboolean isPossible = next(s);\nif (!isPossible) {\nreturn \"Impossible\";\n}\nupdate(s);\n}\nreturn \"Possible\";\n}\nprivate void init(int[] p) {\nsize = p.length + 1;\ndistances = new int[size][size];\nfor (int i = 0; i < size; i++)\nfor (int j = 0; j < size; j++)\ndistances[i][j] = i == j ? 0 : INF;\nfor (int i = 0; i < p.length; i++) {\ndistances[i+1][p[i]] = distances[p[i]][i+1] = 1;\n}\nfor (int k = 0; k < size; k++)\nfor (int i = 0; i < size; i++)\nfor (int j = 0; j < size; j++)\ndistances[i][j] = Math.min(distances[i][j], distances[i][k] + distances[k][j]);\nselectableDist = new HashSet<>();\nselectableNode = new HashSet<>();\nselectableNode.add(0);\n}\nprivate boolean next(int dist) {\nfor (int node : selectableNode) {\nfor (int i = 0; i < size; i++) {\nif (distances[node][i] == dist) {\nreturn true;\n}\n}\n}\nreturn false;\n}\nprivate void update(int dist) {\nselectableDist.add(dist);\nwhile (true) {\nSet additionalNode = new HashSet<>();\nfor (int node : selectableNode) {\nfor (int i = 0; i < size; i++) {\nif (selectableDist.contains(distances[node][i]) && !selectableNode.contains(i)) {\nadditionalNode.add(i);\n}\n}\n}\nif (additionalNode.isEmpty()) {\nbreak;\n}\nselectableNode.addAll(additionalNode);\n}\n}\n}\n\n[/java]\n```\n\n## ConstructLCS\n\nSRM 716 Round 1 - Division I, Level One \n- by [Shizhouxing](https://profiles.topcoder.com/Shizhouxing)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14623)\n\nIf ab<=bc<=ca, we can easily construct a solution in the following way:\n( a ) A has ab ones and follows by ca-ab zeros.\n( b ) B has bc ones.\n( c ) C has bc ones and follows by ca-ab zeros.\n\nYou can validate that the LCS’s between A and B, B and C, C and A are exactly ab,bc,ca respectively.\n\nNow if ab, bc, ca given don’t satisfy ab<=bc<=ca, we can rearrange the order of A,B,C when solving the problem. For example, if ab>bc, we can make the order of strings become C,B,A. Now the LCS’s between the 1st string and the 2nd string, 2nd string and the 3rd string, 3rd string and 1st string are bc,ab,ca respectively. In this way, we’ve swapped ab and bc actually. We can do similar things for ab and ca, bc and ca. Hence we can always change the problem into the one where ab<=bc<=ca.\n\nCode\n```\n[cpp]\n\n#include \nusing namespace std;\nclass ConstructLCS {\npublic:\nvoid solve(int ab, int bc, int ca, string& a, string& b, string& c)\n{\nif (ab > bc)\nreturn solve(bc, ab, ca, c, b, a);\nif (ab > ca)\nreturn solve(ca, bc, ab, a, c, b);\nif (bc > ca)\nreturn solve(ab, ca, bc, b, a, c);\na = b = c = \"\";\nfor (int k = 0; k < ab; k++)\na += '1';\nfor (int k = 0; k < bc; k++)\nb += '1', c += '1';\nfor (int k = 0; k < ca - ab; k++)\na += '0', c += '0';\n}\nstring construct(int ab, int bc, int ca)\n{\nstring a, b, c;\nsolve(ab, bc, ca, a, b, c);\nreturn a + \" \" + b + \" \" + c;\n}\n};\n\n[/cpp]\n``` \n\n## JumpDistancesOnTree\nSRM 716 Round 1 - Division I, Level Two \n- by [Shizhouxing](https://profiles.topcoder.com/Shizhouxing)\n\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/14625)\n\nWe can first get distances between any two nodes by DFS starting from each node.\n\nNow let’s consider which nodes can be chosen by Rabbit Hanako during her trip. First she must choose node 0 as she starts from city 0. Then if she has chosen node u, for another node v, if the distance between u and v is in set S, she can go to city v right after visiting u and then go back to u. So node v can also be chosen. In this way, we get all nodes that can be chosen. We may use BFS to implement it.\n\nNext we should check whether each element in S can appear as a distance between two nodes during the trip. We need check that for each element in S, whether there are two nodes that can be chosen and the distance between them are exactly this element in S. If all elements in S satisfy the condition, it’s possible to have a required trip, otherwise it’s impossible.\n\nCode\n```\n[cpp]\n\n#include \nusing namespace std;\nint dis[2500][2500], ok[2500], valid[2500], n;\nvector E[2500];\nqueue Q;\nvoid dfs(int u, int fa, int* dis) {\nif (fa == -1) dis[u] = 0;\nelse dis[u] = dis[fa] + 1;\nfor (auto v:E[u])\nif (v != fa)\ndfs(v, u, dis);\n}\nclass JumpDistancesOnTree\n{\npublic:\nstring isPossible(vector p, vector S)\n{\nmemset(valid, 0, sizeof(valid));\nmemset(ok, 0, sizeof(ok));\nfor (int i = 0; i < S.size(); ++i) valid[S[i]] = true;\nn = p.size() + 1;\nfor (int i = 0; i < n; ++i) E[i].clear();\nfor (int i = 0; i < p.size(); ++i) E[p[i]].push_back(i + 1), E[i + 1].push_back(p[i]);\nfor (int i = 0; i < n; ++i)\ndfs(i, -1, dis[i]);\nok[0] = true;\nQ.push(0);\nwhile (Q.size()) {\nint u = Q.front(); Q.pop();\nfor (int v = 0; v < n; ++v)\nif (valid[dis[u][v]]) {\nvalid[dis[u][v]] = 2;\nif (!ok[v]) {\nok[v] = true;\nQ.push(v);\n}\n}\n}\nfor (int i = 0; i < S.size(); ++i)\nif (valid[S[i]] < 2) return \"Impossible\";\nreturn \"Possible\";\n}\n};\n\n[/cpp]\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-716-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"HK9NQmWEwqSAx1zJGVtNL","type":"Entry","createdAt":"2020-04-20T12:41:40.146Z","updatedAt":"2026-03-17T23:03:08.129Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":65,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 717","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++"],"creationDate":"2017-07-10T00:00:00.000Z","readTime":"25 min","content":"# Single Round Match 717 Editorials\n\nSRM 717 Editorials are now published. We are still awaiting the submission to the Div I Hard Problem. Thanks to [Srimaan1316](https://profiles.topcoder.com/Srimaan1316) and [Shizhouxing](https://profiles.topcoder.com/Shizhouxing) for contributing to the SRM 717 Editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## NiceTable\nSRM 717 Round 1 - Division II, Level One\n- by [Shizhouxing](https://profiles.topcoder.com/Shizhouxing)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14630)\n\nAssume the table has n rows and m columns.\n\n__Solution I__\nIf we set a value for x[0], since x[0] xor y[0] = t[0][0], y[0] should be (x[0] xor t[0][0]). Then for i (1 <= i < n), since x[i] xor y[0] = t[i][0], x[i] should be (y[0] xor t[i][0]). Similarly, for j (1 <= j < m), since x[0] xor y[j] = t[0][j], y[j] should be (x[0] xor t[0][j]).\nSo we can deduce values of x[1]…x[n-1],y[0]…y[m-1] only from x[0]. Then, we just check whether for each i, j (0 <= i < n, 0 <= j < m), x[i] xor y[j] = t[i][j]. If this is true, the table is nice, otherwise the table is not nice.\n\n__Solution II__\nSince n and m are both very small (n, m <= 5), we can just do brute force. We try all possible values for x[0]…x[n-1], y[0]..y[m-1], and check whether they conform to the given table. The complexity for this algorithm is O(2^(n+m)* nm).\n\n__C++ Code__\nHere is an implementation of both solutions: Solution I is given as the main method isNice(), while Solution II is given as the method bf().\n\n```\n[cpp]\n\n#include \nusing namespace std;\nint n, m, x[100], y[100];\nclass NiceTable\n{\npublic:\n string bf(vector t) {\n for (int i = 0; i < 1 << n; ++i)\n for (int j = 0; j < 1 << m; ++j) {\n for (int k = 0; k < n; ++k) x[k] = bool((1 << k) & i);\n for (int k = 0; k < m; ++k) y[k] = bool((1 << k) & j);\n int ok = true;\n for (int ii = 0; ii < n; ++ii)\n for (int jj = 0; jj < m; ++jj)\n if ((x[ii] ^ y[jj]) != t[ii][jj] - '0')\n ok = false;\n if (ok) return \"Nice\";\n }\n return \"Not nice\"; \n }\n string isNice(vector t)\n {\n n = t.size();\n m = t[0].size();\n\n x[0] = 0;\n y[0] = t[0][0] - '0';\n for (int i = 1; i < n; ++i) x[i] = (t[i][0] - '0') ^ y[0];\n for (int i = 1; i < m; ++i) y[i] = (t[0][i] - '0') ^ x[0];\n\n for (int i = 0; i < n; ++i)\n for (int j = 0; j < m; ++j)\n if (t[i][j] - '0' != (x[i] ^ y[j]))\n return \"Not nice\";\n\n return \"Nice\";\n }\n};\n\n[/cpp]\n``` \n\n## LexmanReplace\nSRM 717 Round 1 - Division II, Level Two \n- by [Srimaan1316](https://profiles.topcoder.com/Srimaan1316)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14631)\n\nIn this problem, you are given 2 strings: s and t. You have to replace some characters of the string s using the characters of string t, such that you obtain the lexicographically largest string. Note that you are not allowed to increase the length of the string s. Also note that in some cases, it is best to leave the string s as is, since that is the optimal answer.\nThis problem can be solved using a greedy approach. The idea is as follows. For better understanding, let us rename the string s as source and string t as allow_chars.\nSort the characters of allow_chars in the non-increasing order. For example, if the string is “egabn” then after sorting it becomes “ngeba”.\n\nLet next = 0.\n\nFor each character in the source string from left to right:\nCompare it with the next-th character of allow_chars.\nIf the character of source is the greater one or equal, do not change anything.\nElse, replace that character with the leftmost character of allow_chars, then increase next by one.\n\nThe time needed to solve this problem is the time taken to traverse source. Let srclen be the length of source, then the time complexity of the above solution is O(srclen).\nThough it was mentioned above that allow_chars is to be sorted in the non-increasing order and initialise next to 0 and then perform comparisons, for ease of implementation, I sorted the string in the non-decreasing order. So, instead of next being zero, it is now len-1.\n\nPseudocode:\n\n```\n[code]\n\nsort allow_chars in non-decreasing order;\nlen := length(allow_chars)\nlen--;\nsrclen := length(source)\nfor(int i = 0; i < srclen; i++) if (len >= 0 && source[i] < allow_chars[len])\nadd allow_chars[len] to the answer and decrement len;\nelse\nadd source[i] to the answer;\nreturn answer;\n[/code]\nC++ code:\n[cpp]\nclass LexmaxReplace\n{\npublic:\nstring get(string s, string t)\n{\nint len=t.length();\nsort(t.begin(),t.end());\nint length=s.length();\nstring ans=\"\";\nlen--;\nfor(int i=0;i<length;i++)\n{\nif(s[i]<t[len]&&len>=0)\n{\nans+=t[len];\nlen--;\n}\nelse\n{\nans+=s[i];\n}\n}\nreturn ans;\n}\n};\n\n[/cpp]\n``` \n\n## DerangementsDiv2\nSRM 717 Round 1 - Division II, Level Three \n- by [Srimaan1316](https://profiles.topcoder.com/Srimaan1316)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14632)\n\nIn a gist, we need to find the number of derangements of the set {1…m} modulo 1000000007. We can solve this using inclusion-exclusion principle.\n__Prerequisites:__\n\n1. To understand more about derangements, check out this Wikipedia link.\n2. For even more ease of understanding of derangements check out this YouTube video.\n3. Learn about inclusion-exclusion principle here.\n4. Check this comment to know how formula for derangements can be derived using inclusion-exclusion principle.\n\nLet A be the set of all permutations of the set {1…n+m}.\nLet Ti be the set of permutations in which the element i is still in its original position.\nLet Dm be the required answer.\nThen,\n\n![SRM717 1](//images.ctfassets.net/piwi0eufbb2g/3XSzPbBlhzcm0PPsHT5Ith/16987ac46f86c9d046f18cbcf30d2e7b/SRM717_1.webp)\n\n (Why only m and not n+m? Because we need to find the number of derangements of only the first m numbers.)\n\n![SRM717 2](//images.ctfassets.net/piwi0eufbb2g/7XLQReNqbONwRFBOUFDAr/f5a05c38455b5b7607d6e7e6b7ead0ae/SRM717_2.webp)\n\nTherefore,\n\n![SRM717 3](//images.ctfassets.net/piwi0eufbb2g/2BttlA6zohsEd7mGw3J4MD/128c1ce252fe9429dfed1da4307ab94f/SRM717_3.webp)\n\nWe can simplify the above equation into:\n\n![SRM717 4](//images.ctfassets.net/piwi0eufbb2g/6n8RZ0JDjgp7iO4ZZaybie/d196364e1e7247a2804b677756aae86f/SRM717_4.webp)\n\nNow that we have the formula ready, we come to the implementation part. Looking at the above formula, it can be understood that we need to compute the factorial of a given number and binomial coefficients C(m,i) where C(m,i) = m! / ((m-i)! * i!). We can make use of the concept of Pascal triangle. Check out this to know more about Pascal triangle.\nAlso, rather than computing factorials multiple number of times, we precompute it once and store them in an array.\nPlease refer my code below to understand the implementation better.\n\n__C++ code__\n\n```\n[cpp]\n\nC++ code\n#include\n#define endl '\\n'\n#define mod 1000000007\nusing namespace std;\nclass DerangementsDiv2\n{\nint fact[104];\nint pascal[103][103];\npublic:int count(int n, int m)\n{\n//Initialising the values of 0! and 1!\nfact[0]=1;\nfact[1]=1;\n// Calculating the factorial values upto 100.\nfor(int i=2;i<104;i++)\nfact[i]=(fact[i-1]*(long long)i)%mod;\n//Computing the Binomial Coefficients using Pascal Triangle.\nfor(int i=0;i<103;i++)\n{\npascal[i][0]=1;\nfor(int j=1;j<=i;j++)\npascal[i][j]=(pascal[i-1][j]+pascal[i-1][j-1])%mod;\n}\nint answer=fact[n+m];\nfor(int i=1;i<=m;i++)\n{\nint val=pascal[m][i];\nif(i&1)\nanswer=(answer-((long long)val*fact[m+n-i] %mod)+mod)%mod;\nelse\nanswer=(answer+((long long)val*fact[m+n-i]%mod))%mod;\n}\nreturn answer;\n}\n};\n\n[/cpp]\n```\n\n__Note__\nCheck out this to know more about performing modulo operation on negative numbers.\n\n## ScoresSequence\nSRM 717 Round 1 - Division I, Level One\n- by [Shizhouxing](https://profiles.topcoder.com/Shizhouxing)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14577)\n\nIt is said that the answer can always be uniquely determined. We can first construct a graph that satisfies the given score.\n\nFrom the scores sequence, we can deduce the in-degree and out-degree of each vertex. Now, we can construct the graph using a greedy algorithm. We consider vertices in the descending order of their out-degrees. For each vertex u, let d be its out-degree. We should choose d other vertices v[1], v[2], …, v[d], and add edges (u,v[1]), (u,v[2]), …, (u,v[d]).\n\nWe can choose those d vertices in the following way: each time, choose a vertex that has the largest remaining in-degree; i.e., its original in-degree minus the number of edges which end at that vertex. For two vertices with same remaining in-degrees, we’ll prefer the one with smaller out-degree. You can easily validate that the solution can’t be better if we don’t construct the graph in this way.\n\nFinally, we can use Floyd-Warshall algorithm to count the number of pairs of vertices (u,v) such that v is reachable from u, in O(n^3) time.\n\n```\n[cpp]\n\n#include \nusing namespace std;\ntypedef long long ll;\ntypedef unsigned long long ull;\ntypedef pair pii;\nconst int inf = ~0U >> 1;\nconst ll INF = ~0ULL >> 1;\nint G[200][200], in[200], out[200];\nint n;\nclass ScoresSequence\n{\npublic:\nint count(vector s)\n{\nn = s.size();\nsort(s.begin(), s.end(), greater());\nfor (int i = 0; i < n; ++i) {\nin[i] = n - 1 - s[i];\nout[i] = s[i];\nfor (int j = 0; j < n; ++j)\nG[i][j] = false;\nG[i][i] = true;\n}\nfor (int i = 0; i < n; ++i) {\nwhile (out[i]--) {\nint j = -1;\nfor (int k = 0; k < n; ++k) if (i != k && !G[i][k] && (j == -1 || in[k] >= in[j]))\nj = k;\nG[i][j] = true;\nin[j]--;\n}\n}\nfor (int k = 0; k < n; ++k)\nfor (int i = 0; i < n; ++i)\nfor (int j = 0; j < n; ++j)\nG[i][j] |= G[i][k] & G[k][j];\nint cnt = 0;\nfor (int i = 0; i < n; ++i)\nfor (int j = 0; j < n; ++j)\nif (G[i][j]) ++cnt;\nreturn cnt;\n}\n};\n\n[/cpp]\n```\n\n## DerangementsStrikeBack\nSRM 717 Round 1 - Division I, Level Two \n- by [Shizhouxing](https://profiles.topcoder.com/Shizhouxing)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14563)\n\nObviously, B[0] = 1 and B[1] = n. Now, let’s compute B[i] from B[0], B[1], …, B[i-1] using dynamic programming.\n\nLet p(i) = j (1<=j<=n+i, j ≠ i). We have:\n\nIf j < i, consider the remaining subproblem:\nIf p(j) = i, now we can simply “remove” positions i and j from the problem to form a subproblem. We now need to arrange the remaining n+i-2 values where first i-2 values can’t be fixed points. The number of ways is B[i-2].\n\nIf p(j) ≠ i, that means for a valid permutation p(1), p(2), …, p(i-1), p(i+1), …, p(n+i), we have p(k) ≠ k (1<=k<=i-1, k ≠ j) and p(j) ≠ i. This is equivalent to the permutation p(1), p(2), …, p(i-1), p(i+1), …p(n+i) such that p(k) ≠ k (1<=k<=i-1). The number of permutations is B[i-1]. For both cases, there are i-1 such j’s, so the total number of permutations is (i-1)(B[i-2]+B[i-1]) If j > i, the remaining subproblem now is to count number of permutations p(1), p(2), …, p(i-1), p(i+1), …, p(n+i) such that p(k) ≠ k (1<=k<=i-1). The number of permutations is B[i-1]. Since there are n such j’s, the total number of permutations is n* B[i-1].\n\nTherefore, B[i] = (i-1) (B[i-2] + B[i-1]) + n*B[i-1] = (i-1) B[i-2] + (n+i-1) B[i-1]. So, we can simply compute B[1], …, B[m] in O(m) complexity.\n\nFinally, B[1] xor B[2] xor … xor B[m] is the answer that should be returned.\n\n```\n[cpp]\n\n#include \nusing namespace std;\nconst int mo = 1000000007;\nint ans, B[200000];\nclass DerangementsStrikeBack\n{\npublic:\nint count(int n, int m)\n{\nB[0] = 1;\nB[1] = n;\nfor (int i = 2; i <= m; ++i)\nB[i] = ((long long)(i - 1) * B[i - 2] + (long long)(n + i - 1) * B[i - 1]) % mo;\nint ans = 0;\nfor (int i = 1; i <= m; ++i)\nans ^= B[i];\nreturn ans;\n}\n};\n\n[/cpp]\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-717-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3d2nxQG8P9jpthe6hOmO6f","type":"Entry","createdAt":"2020-04-20T12:41:41.543Z","updatedAt":"2026-03-17T22:09:02.074Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":47,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 718","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Java"],"creationDate":"2017-07-19T00:00:00.000Z","readTime":"20 min","content":"# Single Round Match 718 Editorials\n\nSome of the SRM 718 Editorials are now published. Check out the editorials of the interesting SRM 718 problems below. Thanks to [Srimaan1316](https://profiles.topcoder.com/Srimaan1316), [marcose18](https://profiles.topcoder.com/marcose18), [Vetteru](https://profiles.topcoder.com/Vetteru) and [bqi343](https://profiles.topcoder.com/bqi343) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## RelativeHeights\nSRM 718 Round 1 - Division II, Level One \n- by [Srimaan1316](https://profiles.topcoder.com/Srimaan1316)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14644)\n\nIn this problem you are given the heights of ‘n’ towers. You are required to choose n-1 of the towers and rank them according to their heights (ranks range between 0 to n-2). So, there would be C(n,n-1) choices. Of these you need to print out the choices that have unique rank ordering. To be more specific, if the rank orderings, for some example sequence, are as follows:\n\n[cpp]\n\n{0,2,3,1,4}\n{4,3,2,1,0}\n{3,4,1,2,0}\n{0,2,3,1,4}\n{2,4,1,0,3}\n{3,4,1,2,0}\n\n[/cpp]\n\nOf the above six possibilities, only 4 orderings look unique and the answer is thus 4.\nYou can follow a brute force method for this problem.\nPseudo Code:\n\n```\n[code]\n\nFor each tower\nRank all the other towers according to their heights.\nPush this rank profile into a set\nReturn the size of the set\n\n[/code]\n```\n\nMy implementation is as follows:\n```\n[cpp]\n\n#include\n#define endl '\\n'\nusing namespace std;\nclass RelativeHeights\n{\npublic:int countWays(vector h)\n{\nint hsiz=h.size();\nset> s;\nfor(int i=0;i> mp;\nvector ind(hsiz-1);\nfor(int j=0;j0) dp[i][j] += dp[i-1][j];\nif (j>0) dp[i][j] += dp[i][j-1];\ndp[i][j] %= mod;\n}\n}\nreturn p1[n] + p2[m] == 0 ? dp[n][m] : 0;\n}\n}\n\n[/java]\n```\n\n## ChainCity\n\nSRM 718 Round 1 - Division II, Level Three \n- by [Vetteru](https://profiles.topcoder.com/Vetteru)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14643)\n\nThe solution of this problem is binary search.\n\nIn each step of binary search, we will find how many transporters required if all buildings must be at most X/2 distances away from nearest transporter.\nNote that X is a center value of binary search range.\n\nIf all buildings are at most X/2 distances away from nearest transporter, we can move from any building to another building at most X distances.\n\nBecause, start building to nearest transporter is at most X/2, and destination from nearest transporter is at most X/2.\n\nSo, total cost must be at most X.\n\nIf less than or equal to k transporters required, X is possible answer and update the binary search range.\n\nIf more than k transporters required, X is impossible answer and also update the search range.\nTo find how many transporters required, just build a transporter from left to right if current building is more than X/2 distances away from nearest transporter.\nExample)\n\ndist = {3, 5, 4}\nk = 2\nBuildings are at 0, 3, 8, 12\n\n__step 1)__ Range is [0, 12(= 3 + 5 + 4)], X = (0 + 12) / 2 = 6\n\nBuilding at 0 is not covered because no transporter is built.\n\nSo, build transporter at 3(= 0 + 6 / 2) and the transporter is covers from 0 to 6.\nWe don’t need to care about left buildings of current building. Because we build transporter from left to right.\n\nSo, build transporter at 3 is most efficient choice in this situation.\n\n3 is covered because transporter is at 3\n\n8 is not covered. So, build transporter at 11(= 8 + 6 / 2) and covers from 8 to 14.\n\n11 is covered by transporter at 11.\n\nNeed 2 transporter to cover all buildings.\nSo, 6 is possible answer.\nNew range is [0, 6].\n\n__step 2)__ Range is [0, 6], X = 3\n\nBuild transporter at 1.5 and [0, 3] is covered.\nNote that we can build transporter at anywhere.\n\n3 is covered.\n\n8 is not covered. So, build transporter at 9.5 and covers from 8 to 11\n\n12 is not covered. build transporter at 13.5\n\nNeed 3 transporter to cover all buildings.\nSo, 3 is impossible answer.\nNew range is [4, 6]\n\n__step 3)__ Range is [4, 6], X = 4 ((int)4.5)\n\nBuild transporter at 2 and covers from 0 to 4\n\n3 is covered\n\n8 is not covered. build transporter at 10 and covers from 8 to 12\n\n12 is covered\n\nNeed 2 transporter and 4 is possible answer.\n\nnew range is [4, 4]\n\n4 is answer of this case.\n\nComplexity:\nD := distance between first building and last building\nN := number of buildings\nTime Complexity : O(NlogD)\n- logD : cost of binary search\n- N : cost to judge\nSpace Complexity : O(N)\n- N : size of distances array\n\n```\n[java]\n\npublic class ChainCity {\npublic int findMin(int[] dist, int k) {\nint[] pos = convert(dist);\nreturn solve(pos, k);\n}\nprivate int[] convert(int[] dist) {\nint[] pos = new int[dist.length + 1];\nint cur = 0;\nfor (int i = 0; i < dist.length; i++) {\npos[i] = cur;\ncur += dist[i];\n}\npos[dist.length] = cur;\nreturn pos;\n}\nprivate int solve(int[] pos, int k) {\nint l = 0, r = pos[pos.length-1];\nwhile (l < r) { int c = (l + r) / 2; if (isPossible(c, k, pos)) { r = c; } else { l = c + 1; } } return r; } private boolean isPossible(int x, int k, int[] pos) { int coverTo = -1; for (int p : pos) { if (p > coverTo) {\nk--;\ncoverTo = p + x;\n}\n}\nreturn k >= 0;\n}\n}\n\n[/java]\n```\n\n## InterleavingParenthesis\nSRM 718 Round 1 - Division I, Level One\n- by [bqi343](https://profiles.topcoder.com/bqi343)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14635)\n\nThis is a straightforward dynamic programming problem. We need to count the number of strings which satisfy the following two conditions:\n\ncontains an equal number of left and right parentheses\n\nat no point in the string does the number of right parentheses exceed the number of left parentheses\n\nLet dp[i][j] be of the number of ways to combine the first i characters of s1 and the first j characters of s2 into a string such that the second condition is satisfied. If there are more right parentheses than left parentheses among the first i characters of s1 and the first j characters of s2, then we set dp[i][j]=0, because the second condition will be violated. Otherwise, we set dp[i][j]=dp[i-1][j]+dp[i][j-1], taking mod 10^9+7 as necessary.\nFinally, we must check if the first condition holds when we use all characters from both strings. If it does, the answer is dp[s1.length()][s2.length()]. Otherwise, the answer is 0.\n\n```\n[cpp]\n\n#include \nusing namespace std;\n#define FOR(i, a, b) for (int i=a; i= 0) {\nif (i > 0) dp[i][j] = (dp[i][j]+dp[i-1][j]) % MOD;\nif (j > 0) dp[i][j] = (dp[i][j]+dp[i][j-1]) % MOD;\n}\nif (cum1[s1.length()]+cum2[s2.length()] == 0) return dp[s1.length()][s2.length()];\nreturn 0;\n}\n};\n\n[/cpp]\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-718-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4D6SKwYjZRlOYWTIUM5PL2","type":"Entry","createdAt":"2020-04-20T12:41:41.734Z","updatedAt":"2026-03-17T19:35:25.916Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":66,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 719","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++"],"creationDate":"2017-09-20T00:00:00.000Z","readTime":"20 min","content":"# Single Round Match 719 Editorials\n\nSome of the SRM 719 Editorials are now published. Check out the editorials of the interesting SRM 719 problems below. Thanks to [Shizhouxing](https://www.topcoder.com/members/Shizhouxing), [nitish_](https://profiles.topcoder.com/nitish_) and [square1001](https://profiles.topcoder.com/square1001) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## LongLiveZhangzj\nSRM 719 Round 1 - Division II, Level One \n- by [Shizhouxing](https://www.topcoder.com/members/Shizhouxing)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14675)\n\nWe need to count the number of words that are exciting in __speech__.\n\nFor each word s[i] in __speech__, we just check whether there is a word in __words__ which is exactly the same as s[i]. If so, word s[i] is considered to be exciting. The answer to the problem is the number of exciting words in __speech__.\n\n__Code__:\n\n```\n[cpp]\n\n#include \nusing namespace std;\nclass LongLiveZhangzj\n{\npublic:\nint donate(vector speech, vector words)\n{\nint ans = 0;\nfor (auto x:speech) {\nint exciting = 0;\nfor (auto y:words)\nif (x == y) exciting = 1;\nans += exciting;\n}\nreturn ans;\n}\n};\n\n[/cpp]\n```\n\n## LongMansionDiv2\nSRM 719 Round 1 - Division II, Level Two\n- by [nitish_](https://profiles.topcoder.com/nitish_)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14674)\n\nIn total, it will be optimal to move only (N + M - 1) steps where N - the number of rows, M - the number of columns.This problem is a problem of a shortest path in a 2-D grid. Weights for crossing each box are given in an int[].The best solution for this problem is by greedy approach.\n\nReason for this is that it is optimal to choose a row with minimum weight and move horizontally across that row only because it will add minimum weight to the solution. Thus, the solution will be equal:\n\nans = M*(minumum_weight_among_all_rows) + cost_of_single_step_on_every_other_row.\n\n__Code__:\n\n```\n[cpp]\n#include \nusing namespace std;\nclass LongMansionDiv2 {\npublic:\nlong long minimalTime(int M, vector t) {\nlong long ans = 0;\nlong long sum = 0;\nfor(int i =0; i < t.size(); ++i)\nsum += t[i];\nlong long minm = *min_element(t.begin(), t.end());\nans = minm*M + sum - minm;\nreturn ans;\n}\n}\n\n[/cpp]\n```\n\n__Note:__ use long long to avoid overflow.\n__Complexity:__ O(N), since we iterate over the input array.\n\n## TwoDogsOnATree\nSRM 719 Round 1 - Division II, Level Three \n- by [nitish_](https://profiles.topcoder.com/nitish_)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14673)\n\nFirstly, root the tree at vertex 0. In a tree, between any two nodes, there is exactly only one path. Hence, in order to solve this problem, we should be able to find the XOR of all the weights on the path as quickly as possible. This can be done in O(N) preprocessing and O(1) for query.\n\nFind the XOR of edges of all the vertex from the root vertex and store it in XOR[].\nThus, XOR[x] will store the XOR of all the edges in the path between node x and the root. Now to compute this between any two vertex (x , y), simply xor the XOR[x]^XOR[y] in O(1). This statement is true, because if vertex x and y lie different side of root, then the path must go through the root, and one path is kind of extension of another. Otherwise, if they lie on the same side of root, then the repeated edges are disabled with xor operation, because x^x = 0; and 0^x = x. That’s why the above statement is correct.\n\nNow, suppose you choose a pair of nodes (a,b) for DOG 1 and another pair of nodes (c,d) for DOG 2. If there is no common edge between the two paths, then the result of A XOR B i.e. A^B = (XOR[a] ^ XOR[B])^(XOR[C]^XOR[d]), where A and B were the results for first and second paths respectively.\n\nNow, consider the other case, when there is overlapping of edges, then in that case, we can choose another permutation formed with same set of nodes which does not overlap i.e : either {(a, c) ,(b,d)} or {(a,d), (b,c)}. Result for any of these combination would result same as above. A^B = (XOR[a] ^ XOR[B])^(XOR[C]^XOR[d]).\n\nThus, the problem reduces to choosing 4 vertex a, b, c, d for which the XOR[a]^XOR[b]^XOR[C]^XOR[d] is maximum.\n\nTo solve this, There are many methods:\nFirstly, make a set of distinct values of all the pairs from the available nodes. This will give you maximum of N* N distinct values.\n\nNow, among all these pairs, Take the XOR of all pairs and return the maximum from it.\n\n__Code__:\n\n```\n[cpp]\n\n#include \n#include \n#include \n#include \nusing namespace std;\nclass TwoDogsOnATree {\npublic:\nint XOR[1020];\nint maximalXorSum(vector parent, vector w)\n{\nint n = parent.size() + 1;\nint ans = 0;\nset st;\nfor (int i = 1; i < n; ++i) {\nXOR[i] = XOR[parent[i - 1]] ^ w[i - 1];\n}\nfor (int i = 0; i < n; ++i) {\nfor (int j = 0; j < i; ++j)\nst.insert(XOR[i] ^ XOR[j]);\n}\nset::iterator it1;\nset::iterator it2;\nfor (it1 = st.begin(); it1 != st.end(); ++it1) {\nfor (it2 = st.begin(); it2 != st.end(); ++it2)\nans = max(ans, *it1 ^ *it2);\n}\nreturn ans;\n}\n};\n\n[/cpp]\n```\n\n__Complexity__: O(N ^ 4), since there will be N^2 elements in st set.\n\n## LongMansionDiv1\nSRM 719 Round 1 - Division I, Level One \n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14641)\n\n__Make problem more simple__\n![SRM719 1](//images.ctfassets.net/piwi0eufbb2g/1XwCxHDXT8e0do3ZrHIAKH/dbcfb97436d279e836190a2b9ca3e2c2/SRM719_1.webp)\n\nYou are given a grid with H (H ≤ 50) rows by W (W ≤ 109) columns. Cell in i-th row and j-th column denotes (i, j). Each cell in a grid has written a positive integer. Also, each cell in the same row has written the same value ai. You are given the position of starting cell (sx, sy) and finishing cell (gx, gy). You can move to 4-directions (up, down, right, left). Calculate the minimum sum of numbers written in passed cells.\n\n__The solution__\n\nThe optimal solution is, amazingly, can always construct by following 3 steps. Pay attention that is assuming sy ≤ gy (because if sy > gy you can swap start and goal).\na. Move some cells upwards or downwards.\nb. Move right gy-sy times.\nc. Move some cells upwards or downwards and reach goal.\n\n![SRM719 2](//images.ctfassets.net/piwi0eufbb2g/2qDJgrXat3sEprJdmxQywS/e46d4abb1348514a0d3d907b167301c3/SRM719_2.webp)\n\nYou can choose row which uses in step b (row of finishing step a). In the constraint H ≤ 50, you can brute-force and get minimum of it. Also, you can calculate the cost of the path in O(H), so the total time complexity is O(H2).\n\n__Why this is optimal?__\n\n1. Moving extra left and right direction is not good\nMoving left and right more times than shortest, is a waste of cost. Why? You can see from the picture.\n\n![SRM719 4](//images.ctfassets.net/piwi0eufbb2g/4GG1WTmkYiEvxH5jbLnxd0/d71dd22a2347f7e4a9d56f7e93b70e7c/SRM719_4.webp)\n\nYou can erase the left arrow (assuming sy ≤ gy) and corresponding right arrow. Also, you can move the disconnected part one cell right. As all numbers in same row is same, the reduced cost is always the cost in left arrow row and plus cost in right arrow row, so it is always higher than zero.\n\n2. Moving right in different row is not good\nFirst, see the example in the picture.\n\n![SRM719 6](//images.ctfassets.net/piwi0eufbb2g/4XwScvRVt9WD9Wha0XgES9/8a6469f685d1b99465e33a85ece15057/SRM719_6.webp)\n\nIn this example, the left one costs 3A+3B+C, the middle one costs 5A+B+C, and the right one costs A+5B+C. You can see that for any real number A, B, C, 3A+3B+C≤max(5A+B+C,A+5B+C). You can prove it by solving in case of A>B, A=B, A\n#include \n#include \nusing namespace std;\nclass LongMansionDiv1 {\npublic:\nlong long minimalTime(vector v, int sx, int sy, int ex, int ey) {\nint n = v.size();\nlong long ret = 1LL << 62;\nfor (int i = 0; i < n; i++) {\nlong long res = 1LL * v[i] * (abs(sy - ey) - 1);\nfor (int j = min(sx, i); j <= max(sx, i); j++) res += v[j];\nfor (int j = min(ex, i); j <= max(ex, i); j++) res += v[j];\nret = min(ret, res);\n}\nreturn ret;\n}\n};\n\n[/cpp]\n```\n\n__Bonus__: Also, if you use prefix sum technique, you can get the answer in time complexity O(H). Let’s think about the solution!","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-719-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"5LR63W2skhcYLsxcAhOkYc","type":"Entry","createdAt":"2020-04-20T12:41:37.094Z","updatedAt":"2026-03-15T19:15:52.351Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":53,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 720","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Java"],"creationDate":"2017-08-30T00:00:00.000Z","readTime":"15 min","content":"# Single Round Match 720 Editorials\n\nSRM 720 Editorials are now published. Thanks to [kapillamba4](https://profiles.topcoder.com/kapillamba4) and [marcose18](https://profiles.topcoder.com/marcose18) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## DistinctGridEasy\nSRM 720 Round 1 - Division II, Level One\n- by [marcose18](https://profiles.topcoder.com/marcose18)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14668)\n\nWe will solve this question with bruteforce. For each row and each column we will check if that row or column contains exactly k distinct elements or not. To check that we can use HashSet (Java) or unordered_set (C++).\n\nBelow is the working code in Java explained with appropriate comments.\n\n__Java Code__\n\n```\n[cpp]\n\nimport java.util.*;\nimport java.util.regex.*;\nimport java.text.*;\nimport java.math.*;\npublic class DistinctGridEasy {\npublic String checkGrid(int n, int k, int[] grid) {\nint matrix[][] = new int[n][n];\nfor (int i = 0; i < n; i++) { // make actual 2D matrix from given array.\nfor (int j = 0; j < n; j++)\nmatrix[i][j] = grid[i * n + j];\n}\nHashSet set;\nfor (int i = 0; i < n; i++) {\nset = new HashSet<>();\nfor (int j = 0; j < n; j++) //check if ith row contains exactly k elements.\nset.add(matrix[i][j]);\nif (set.size() != k)\nreturn \"Bad\";\nset = new HashSet<>();\nfor (int j = 0; j < n; j++) //check if jth column contains exactly k elements\nset.add(matrix[j][i]);\nif (set.size() != k)\nreturn \"Bad\";\n}\nreturn \"Good\"; /*Finally return Good if each row and column contains\n} exactly k distinct elements.\n*/\n}\n[/cpp]\n```\n\n## MinProduct \nSRM 720 Round 1 - Division II, Level Two \n\n- by [kapillamba4](https://profiles.topcoder.com/kapillamba4)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14666)\n\nWe are given multiple copies of digits whose value is between 0 to 9 inclusive.\nUsing those digits we have to construct 2 numbers A and B such that their product is minimum and for both number A, B leading zeroes are allowed.\n\nSize of number A should be __blank1__ digits.\nSize of number B should be __blank2__ digits.\n\n__Constraints__\n1 ```<``` blank1 ```<``` 10\n1 ```<``` blank2= blank1+blank2. Therefore the maximum size of our digits vector will 9+9 = 18 (blank1 + blank2)\n\nSize of our digits vector is now equal to blank1+blank2.\n\nNow for each digit in digits vector we can decide to either put it in A or B. Therefore the total number of possibilities of creating A and B will be 2**(blank1+blank2) which is at max equal to 2**18 = 262144\n\nWe can iterate from 0 to 2**(blank1+blank2) using bitmask and for each bit ‘j’ in each number ‘i’ from 0 to 2**(blank1+blank2) we put digits[j] in A if j’th bit is set (is one) else we place it in B if the j’th bit is not set (is zero).\n\nFor each number ‘i’, after constructing A and B we check if size of A is blank1 and size of B is blank2, We update our answer with each iteration.\n\nRefer here to know how to iterate over of all subsets of a set using bitmasks.\nThe time complexity of the above solution is O(size * (2**size) ) where size is length of our digits vector.\n\n(maximum value of size is 18 as per the problem)\n\n__C++ Code__\n\n```\n[cpp]\n\n#include\nusing namespace std;\ntypedef long long ll;\nclass MinProduct {\nll pow2[20];\npublic:\nll findMin(vector amount, int blank1, int blank2) {\nstring digits;\nint j = 0;\nfor(int i = 0; i < blank1+blank2; i++) {\nwhile(amount[j] == 0) ++j;\ndigits.push_back('0'+j);\namount[j]--;\n}\npow2[0] = 1;\nfor(ll i = 1; i < 20; i++) {\npow2[i] = pow2[i-1]*2;\n}\nll ans = LLONG_MAX;\nfor(ll i = 0; i < pow(2, digits.size()); i++) {\nstring A, B;\nfor(ll j = 0; j < digits.size(); j++) {\nif(i & pow2[j]) {\nA.push_back(digits[j]);\n} else {\nB.push_back(digits[j]);\n}\n}\nif(A.size() != blank1 || B.size() != blank2) {\ncontinue;\n}\nans = min(ans, stoll(A)*stoll(B));\n}\nreturn ans;\n}\n};\n[/cpp]\n```\n\n## SumProduct\nSRM 720 Round 1 - Division I, Level One\n\n- by [kapillamba4](https://profiles.topcoder.com/kapillamba4)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14661)\n\nWe are given multiple copies of digits from 0 to 9, an array ‘amount’ denotes the number of occurance of each digit from 0 to 9 inclusive.\n\nWe have to add the product of all distinct pairs of numbers A, B constructed using given copies of digits. Here leading zeroes are allowed.\nSize of number A should be __blank1__ digits.\nSize of number B should be __blank2__ digits.\n\n__Constraints:__\n0 < amount[i] <= 100\n1 < blank1 <= 100\n1 < blank2 <= 100\n\nFor each of i’th place in number A and j’th place in number B in Base-10 representation, fix digit value di for number A and digit value dj for number B and then calculate the number of occurrences of distinct pairs (A, B) such that for the pair di is present at i’th place in A and \ndj is present at j’th place in B.\n0 ```<``` i ```<``` blank1\n0 ```<``` j ```<``` blank2\n0 ```<=``` di ```<``` 10\n0 ```<=``` dj ```<``` 10\n\nAdd the result of ((10**i) * di * (10**j) * dj) * (occurrences) to the final ans with each iteration where `occurances` is the number of distinct pairs (A, B) such that di digit occurs at i'th place in A and dj digit occurs at j'th place in B.\n\nLet d[size][x][di][dj] denote the number of ways to fill in ‘size’ places using digits only available from x to 9 inclusive and digits di, dj are fixed.\n\nThe `occurances` can be calculated as d[blank1+blank2-2][0][di][dj] after placing di at i’th place and dj at j’th place.\n\nAll blank1+blank2-2 places (after fixing di and dj digits) in base-10 representation for A and B are distinct. Therefore choosing `y` places among `size` places is given by nCr(size, y) = size!/(y!* (size-y)!)\n\nTherefore the recursive relation is d[size][x][di][dj] = ∑d[size-y][x+1][di][dj]* nCr(size, y) where 0 <= y <= min(size, amount[i])\n\nd[size][x][di][dj] = 0 if size != 0 and x = 10 (maximum value of a digit in base-10 representation + 1 = 9 + 1 = 10)\n\nd[size][x][di][dj] = 1 if size = 0 and x = 10 (maximum value of a digit in base-10 representation + 1 = 9 + 1 = 10)\n\nBinomial coefficient (nCr) can be calculated in constant time if factorials and modular inverse of factorials of numbers from 0 to blank1+blank2 are calculated and memoized beforehand.\nTherefore the time complexity for choosing i, j, di and dj will be O(blank1* blank2 * max(di)* max(dj)) and time complexity for calculating the number of distinct pairs (A, B) after using memoization will be around O((blank1+blank2-2)* max(x)* max(di)* max(dj)* min(amount[x], size))\nO(blank1* blank2 * max(di)* max(dj) + (blank1+blank2-2)* max(x)* max(di)* max(dj)* min(amount[x], size))\n\nwhere maximum value of di, dj, x can be 10\n\nand maximum value of min(amount[x], size) can be 10\n\n__C++ Code__\n\n```\n[cpp]\n\n#include\nusing namespace std;\ntypedef long long ll;\nconst ll MOD = 1000000007;\nll d[205][10][10][10];\nll fac[205];\nll invFac[205];\nclass SumProduct {\npublic:\nll power(ll a, ll b) {\nif(a == 0) return 0;\nif(b == 1) return a;\nif(b == 0 || a == 1) return 1;\nif(b % 2) {\nreturn (power((a*a)%MOD, b/2)*a)%MOD;\n} else {\nreturn power((a*a)%MOD, b/2);\n}\n}\nll nCr(ll n, ll r) {\nreturn (((fac[n]*invFac[r])%MOD)*invFac[n-r])%MOD;\n}\nll occur(int i, int size, vector &amount, int x, int y) {\nif(size != 0 && i == amount.size()) return 0;\nif(size == 0 && i == amount.size()) return 1;\nif(d[size][i][x][y] != -1) return d[size][i][x][y];\nll ans = 0;\nfor(int j = 0; j <= min(amount[i], size); j++) {\n// nCr(size, j) gives number of ways to\n// choose ‘j’ places from ‘size’ places\nans += (occur(i+1, size-j, amount, x, y)*nCr(size, j))%MOD;\nans %= MOD;\n}\nreturn (d[size][i][x][y] = ans);\n}\nll findSum(vector amount, int blank1, int blank2) {\nfor(int i = 0; i < 205; i++) {\nfor(int j = 0; j < 10; j++) {\nfor(int k = 0; k < 10; k++) {\nfor(int z = 0; z < 10; z++) {\nd[i][j][k][z] = -1;\n}\n}\n}\n}\nfac[0] = 1;\ninvFac[0] = 1;\nfor(ll i = 1; i < 205; i++) {\nfac[i] = (fac[i-1]*i)%MOD;\ninvFac[i] = (invFac[i-1]*power(i, MOD-2))%MOD;\n}\nll ans = 0;\nfor(int i = 0; i < blank1; i++) {\nfor(int j = 0; j < blank2; j++) {\nfor(int di = 0; di < 10; di++) {\nfor(int dj = 0; dj = 0 && amount[dj] >= 0) {\nll a = (di*power(10, i))%MOD;\nll b = (dj*power(10, j))%MOD;\nll occurance = occur(0, blank1+blank2-2, amount, di, dj);\nans += (((a*b)%MOD)*occurance)%MOD;\nans %= MOD;\n}\namount[di]++;\namount[dj]++;\n}\n}\n}\n}\nreturn ans;\n}\n};\n\n[/cpp]\n\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"7M4Mi2lee2fNvwwkdUle1b","type":"Entry","createdAt":"2020-04-20T12:41:39.297Z","updatedAt":"2020-04-20T12:41:39.297Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Aditya","tcHandle":"Aditya"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-720-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2KmP6yXtve3KIAk0ChzYOk","type":"Entry","createdAt":"2020-04-20T12:41:37.073Z","updatedAt":"2026-03-15T17:49:51.550Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":66,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 721","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Python","Java"],"creationDate":"2017-11-21T00:00:00.000Z","readTime":"25 min","content":"# Single Round Match 721 Editorials\n\nSome of the SRM 721 Editorials are now published. Check out the editorials of the interesting SRM 721 problems below. Thanks to [erk52](https://profiles.topcoder.com/erk52), [marcose18](https://profiles.topcoder.com/marcose18), [nitish_](https://profiles.topcoder.com/nitish_), [hl_a_k](https://profiles.topcoder.com/hl_a_k) and [square1001](https://profiles.topcoder.com/square1001) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## FlightDataRecorder\nSRM 721 Round 1 - Division II, Level One \n\n- by [erk52](https://profiles.topcoder.com/erk52)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14711)\n\nYou are given two arrays: one contains headings in degrees (e.g., 0 is east, 90 is north, 180 is west, 270 is south), and one contains distances travelled in those headings. The goal is to calculate the final position of the airplane that followed the given headings for the given directions. For example, if you are given [0,90], [3, 4], this describes a plane that flew 3 units east, and 4 units north, resulting in a final distance of 5 from the origin.\nThis is a straightforward problem that relies on some simple trigonometry. We have an array of headings, and an array of distances. All we need to do is take each heading-direction pair, convert this into an x-distance and a y-distance, and sum each of these components to find the final position of the plane.\n\nTo convert from heading-direction to 2D Cartesian coordinates, we apply a simple transformation:\nx = r cos θ\ny = r sin θ\n\nIn this problem, r is the distance and theta is the heading. The built-in sin and cos functions are expecting the argument in radians. So we have to multiply by a factor of pi/180 to convert our headings from degrees into radians.\nOnce we know the final x and y positions of the plane, finding the distance is a simple application of the Pythagorean theorem:\nd^2 = x^2 + y^2\nd = sqrt(x^2 + y^2)\n\n__Python Code:__\n\n```\n[cpp]\n\nimport math\nclass FlightDataRecorder:\ndef getDistance(self, heading, distance):\ntotal_x, total_y = 0,0\nfor i in range(len(heading)):\nr = distance[i]\ntheta = heading[i]\ntotal_x += r*math.cos(math.pi*theta/180)\ntotal_y += r*math.sin(math.pi*theta/180)\nreturn math.sqrt(total_x**2 + total_y**2)\n\n[/cpp]\n```\n\n## RememberWordsEasy\nSRM 721 Round 1 - Division II, Level Two \n\n- by [marcose18](https://profiles.topcoder.com/marcose18)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14708)\n\nWe will solve this question by bruteforce.\n\nThe possible values on day d1 will be between 0 and w1, inclusive. And for each possible value(let’s say i) where 0 <= i <= w1, possible values of words learnt on day (d1 + 1) will be i - 1, i, i + 1, because absolute difference can be atmost 1 between each consecutive days.\nNow, for each combination of words learnt on day d1 and day (d1 + 1) which is nothing but (i, i - 1), (i, i), (i, i + 1), we will calculate minimum words that can be learnt in both semesters and maximum words that can be learnt in both semesters. If total words that are to be learnt in a particular semester is in between minimum and maximum for that particular semester in both cases, then we return string “Possible”. Otherwise if no combination exists, the answer is “Impossible”.\n\nNow if words learnt on day d1 is i, then minimum possible words learnt in first semester will be i + (i - 1) + (i - 2) …...max(1, i - d1 + 1) and maximum words that can be learnt are i + (i + 1) + (i + 2) …….(i + d1 - 1). Similarly it can be calculated for the second semester.\n\n__Java Code:__\n\n```\n[cpp]\n\nimport java.util.*;\nimport java.util.regex.*;\nimport java.text.*;\nimport java.math.*;\npublic class RememberWordsEasy {\nstatic boolean check(int i, int j, int w1, int w2, int d1, int d2) {\nlong low_i = Math.min(d1, i) * 1L * (i + Math.max(1, i - d1 + 1)) / 2;\nlong high_i = d1 * 1L * (i + i + d1 - 1) / 2;\nlong low_j = Math.min(d2, j) * 1L * (j + Math.max(0, j - d2 + 1)) / 2;\nlong high_j = d2 * 1L * (j + j + d2 - 1) / 2;\nif (w1 >= low_i && w1 <= high_i && w2 >= low_j && w2 <= high_j)\nreturn true;\nreturn false;\n}\npublic String isPossible(int d1, int d2, int w1, int w2) {\nfor (int i = 0; i <= w1; i++) {\nfor (int j = i - 1; j <= i + 1; j++)\nif (check(i, j, w1, w2, d1, d2))\nreturn \"Possible\";\n}\nreturn \"Impossible\";\n}\n}\n\n[/cpp]\n```\n\n## ApocalypseEasy\nSRM 721 Round 1 - Division II, Level Three \n\n- by [hl_a_k](https://profiles.topcoder.com/hl_a_k)\n\n[Problem Details](http://archive.topcoder.com/ProblemStatement/pm/14710)\n\nThe key observation of this problem is that this is a maximum bipartite matching problem.\nThe nodes in position will be destroyed; others nodes will be safe.\nIn the problem statement, we know, in each turn we can move each token at most once. During the turns each node may temporarily contain arbitrarily many tokens. At the very end, each node must again contain at most one token.\n\nSo, every node in position corresponds to some safe node. We can precalculate the matching graph, then find the maximum bipartite matching.\n\n__Code__:\n\n```\n[cpp]\n\n#include \nusing namespace std;\n#define ll long long\n#define FT(i,f,t) for(int i=f;i<=t;++i) #define TF(i,t,f) for(int i=t;i>=f;--i)\n#define REP(i,n) for(int i=0;i p, vector position, int t) {\nint n = p.size() + 1;\nREP(i,55)\nREP(j,55){\ng[i][j] = INF;\n}\nMM(bpGraph,false);\nREP(i,n - 1){\ng[p[i]][i+1] = g[i+1][p[i]] = 1;\n}\nREP(k,n)\nREP(i,n)\nREP(j,n){\ng[i][j] = min(g[i][j],g[i][k] + g[k][j]);\n}\nset ps(position.begin(),position.end());\nset valid;\nREP(i,n){\nif(ps.find(i) == ps.end()){\nvalid.insert(i);\n}\n}\nfor(auto &p:position){\nfor(auto &_t:valid){\nif(g[p][_t] <= t){\nbpGraph[p][_t] = true;\n}\n}\n}\nreturn maxBPM(bpGraph);\n}\n};\n\n[/cpp]\n```\n\n## RememberWords\nSRM 721 Round 1 - Division I, Level One \n\n- by [nitish_](https://profiles.topcoder.com/nitish_)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14707)\n\nTo solve this problem, we have to be concerned about the d1-th day and (d1+1)-th day of the college semester.\n\nThe difference between the work load between these two days should be less than or equal to 1. If we are able to find a solution for this, then solution exists, otherwise not.\n\nWe will find the maximum and minimum permissible value for the day d1 and day (d1+1). Now, it it easy to see that any value can be achieved between this range (because we can increase or decrease or remain constant our value over a range). To find this, we will use binary search over the search space.\n\nIn case of finding the minimum permissible value we can assume a value which could be achieved at the end of sequence and rest of the terms before that is greater than that, thus the sum of range is given by = a*n + (n*n-1)/2 where a = last term of sequence, n = number of terms.\nIn case of maximum permissible value, if we want to a maximum value at the end of a sequence, then other terms before than that should decrease by one. Thus the sum of this range is given by = a*n - (n*n-1)/2. Be sure to handle the case where number of terms(i.e. \"d\" ) gets lower that your assumed maximum value, some of your terms of arithmetic progression will get negative. We dont want that.\n\n```\n[cpp]\n\n#include \n#define ll long long\n#define INF 1000000000LL\nusing namespace std;\nclass RememberWords {\npublic:\nll bin_min(ll d, ll w) //d = no. of terms, w = sum of terms\n{\nll lo= 0LL, hi = INF, mid;\nwhile(hi > lo)\n{\nmid =(hi +lo)/2;\nll sum = mid*d + d*(d-1)/2;\nif(sum < w) lo = mid +1; else hi = mid; } return lo; } ll bin_max(ll d, ll w) { ll lo = 0LL, hi = INF, mid; while(hi> lo)\n{\nmid = (hi+lo+1)/2;\nll sum = d*mid - d*(d-1)/2;\nif(mid < d)\n{\nsum = mid*(mid+1)/2;\nif(sum < w) lo = mid; else hi = mid-1; } else { if(sum > w)\nhi = mid-1;\nelse\nlo = mid;\n}\n}\nreturn lo;\n}\nstring isPossible(int d1, int d2, int w1, int w2) {\nll min1,min2,max1,max2;\nmin1 = bin_min(d1,w1);\nmax1 = bin_max(d1,w1);\nmax2 = bin_max(d2,w2);\nmin2 = bin_min(d2,w2);\n//cout< max1 or min2 > max2)\nreturn \"Impossible\";\nelse if(max1+1 == min2)\nreturn \"Possible\";\nelse if(max2+1 == min1)\nreturn \"Possible\";\nelse if(max(min1, min2) <= min(max1, max2))\nreturn \"Possible\";\nelse return \"Impossible\";\n}\n};\n\n[/cpp]\n```\n\n## GraphAndPairs\nSRM 721 Round 1 - Division I, Level Two\n\n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14714)\n\n![SRM721 1](//images.ctfassets.net/piwi0eufbb2g/4AYmT9JOMc0nkEQIJ3NAWj/3986eef923668f5e0af3117d10572bf8/SRM721_1.webp)\n\nLook at the picture in above. This graph makes 25 pairs of vertices (x, y) in the which distance between vertex x and vertex y is exactly 4.\n\nLet a be the number of red vertices, let b be the number of blue vertices, and let c be the number of green vertices.\n\nLet’s consider the case which constructs the tree graph by adding edges, from each red vertex to the first green vertex, from each blue vertex to the last green vertex, and from the i-th green vertex to the (i+1)-st green vertex (1 ≤ i ≤ c-1).\n\nIf c ≥ 2, the distance between vertex x and vertex y is c+1 if and only if either x or y is a red vertex and another is a blue vertex. The reason is, if one is a red vertex and another is blue, the distance between x and y is c+1, and if either x or y belongs to a green vertex, the distance between x and y is less than c+1, and if x and y are both red vertices, the distance is 2 if x ≠ y and otherwise 0, and similarly if x and y are both blue vertices.\n\nSo, if you set c = d-1, the number of good pairs is ab and the number of vertices is a + b + c = + b + d - 1. Note that this statement is only established if c ≥ 2 (therefore d ≥ 3).\n\nThe case of d ≥ 3\n\nLet √k be the floor of the square root of k.\nIf you set (a, b) = (√k, √k), you can make (√k)2 good pairs with 2√k + d - 1 vertices.\nNow you have to make extra k - (√k)2 good pairs by making another graph as connected components. If you set (a, b) = (k - (√k)2, 1), you can make k - (√k)2 good pairs with k - (√k)2 + d vertices.\n\nBy combining the two graphs, you can make s good pairs with 2√k + k - (√k)2 + d - 1 vertices. As k ≤ 50000, the maximum value of √k is 223, and the maximum value of k - (√k)2 is 444 because it’s the difference of s and the largest square number less than or equal to k.\n\nAs d ≤ 50, the maximum number of vertices is less than or equal to 2 × 233 + 444 + 2 × 50 - 1 = 989. Since the graph is a forest, the number of edges is less than number of vertices, so it satisfies the condition of |V| ≤ 1000, |E| ≤ 1000 (|V| is the number of vertices, and |E| is the number of edges).\nThe case of d = 2\n\nThe constructing style of case d ≤ 3 and case d = 2 is quite different.\nFirst, a star graph Sa = K1,a contains C(a, 2) = a(a-1)/2 vertex pairs which distance between one and another is 2.\n\nSecond, a path graph Pb contains max(b-2, 0) vertex pairs which distance between one and another is 2.\n\nIf you maximize a, you can minimize b since a ≥ 1. Let’s think about maximizing a. Solving the inequality a(a-1)/2 ≤ k, you get\n\n![SRM721 2](//images.ctfassets.net/piwi0eufbb2g/5A3LZnfJ4ApHpaK9v6JTYy/e6229b2d7c5b82296130e0dd0361b293/SRM721_2.webp)\n\nSince k ≥ 1, a = 1 is always one solution, so the maximum value of a is\n\n![SRM721 3](//images.ctfassets.net/piwi0eufbb2g/25CEF0LSixyhD3kouUHEV4/ca8c5cb19fa87bbdd6e41837750e6087/SRM721_3.webp)\n\nIf you set (a, b) =\n\n![SRM721 4](//images.ctfassets.net/piwi0eufbb2g/6kR2Xw1OVZyNyX1r9563fB/f7e0e5dceb9d873ee172b6fffe22d5d8/SRM721_4.webp)\n\n,the number of good pairs will be k. Since k ≤ 50000 => a ≤ 316, it follows that b ≤ ½ × 316 × 315 - ½ × 315 × 314 = 315, so the number of vertices will be less than or equal to a + b + 3 = 624. Since the graph is a forest, the number of edges is less than the number of vertices, so it satisfies the condition of |V| ≤ 1000, |E| ≤ 1000.\n\n```\n[cpp]\n\n#include \n#include \n#include \nusing namespace std;\nclass GraphAndPairs {\npublic:\nvector construct(int d, int k) {\nvector ret;\nif (d >= 3) {\nint sq = sqrt(k) + 1.0e-6;\nint a1 = sq, b1 = sq;\nint a2 = k - sq * sq, b2 = 1;\nfor (int i = 0; i < d - 2; i++) {\nret.push_back(i);\nret.push_back(i + 1);\n}\nfor (int i = 0; i < a1; i++) {\nret.push_back(0);\nret.push_back(i + d - 1);\n}\nfor (int i = 0; i < b1; i++) {\nret.push_back(d - 2);\nret.push_back(i + a1 + d - 1);\n}\nfor (int i = 0; i < d - 2; i++) {\nret.push_back(i + a1 + b1 + d - 1);\nret.push_back(i + a1 + b1 + d);\n}\nfor (int i = 0; i < a2; i++) {\nret.push_back(a1 + b1 + d - 1);\nret.push_back(i + a1 + b1 + 2 * d - 2);\n}\nfor (int i = 0; i < b2; i++) {\nret.push_back(a1 + b1 + 2 * d - 3);\nret.push_back(i + a1 + b1 + a2 + 2 * d - 2);\n}\n}\nelse {\nint a = (1 + sqrt(8 * k + 1)) / 2 + 1.0e-6, b = k - a * (a - 1) / 2;\nfor (int i = 0; i < a; i++) {\nret.push_back(0);\nret.push_back(i + 1);\n}\nfor (int i = 0; i < b + 1; i++) {\nret.push_back(i + a + 1);\nret.push_back(i + a + 2);\n}\n}\nret.insert(ret.begin(), *max_element(ret.begin(), ret.end()) + 1);\nreturn ret;\n}\n};\n\n[/cpp]\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-721-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2esng9v2bJ6ssDIH4EeAIW","type":"Entry","createdAt":"2020-04-20T12:41:37.090Z","updatedAt":"2026-03-15T17:18:16.522Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":87,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 722","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Python"],"creationDate":"2017-12-10T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 722 Editorials\n\nSRM 722 Editorials are now published. Thanks to [OB3LISK](https://profiles.topcoder.com/OB3LISK), [square1001](https://profiles.topcoder.com/square1001), [kapillamba4](https://profiles.topcoder.com/kapillamba4) and [asmn](https://profiles.topcoder.com/asmn) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## HillClimber\nSRM 722 Round 1 - Division II, Level One \n\n- by [OB3LISK](https://profiles.topcoder.com/OB3LISK)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14727)\n\nThe problem HillClimber gives us a set of mountains, and asks us to find the longest sequence of mountains that increase in height. (Said another way, what's the longest streak of mountains where we have to continuously climb up, without going down or remaining at the same height.)\nWe can see that this problem is a simple \"Longest Increasing Sequence\" (not to be confused with the famous Dynamic Programming problem, \"Longest Increasing SUBsequence\").\n\nWe're given an array of mountain heights as input. We'll need to maintain two variables, the longest sequence of uphill climbing we've ever seen, and the sequence of uphill climbing for the mountain series we're currently on.\n\nTraversing each element of the array of heights from left to right, we'll keep track of the mountain we're currently on, and the next mountain in line. If the next mountain is bigger than the mountain we're currently on, then we know that we're going uphill, which means we increase our local longest variable by one. It's also at this step where we decide, \"if this local longest is bigger than the longest I've seen so far, then we know that this new sequence is the longest I've ever seen\", and so we set our total longest the local longest.\n\nAfter traversing all but the last mountain, our longest uphill sequence variable will contain our final answer.\n\n```\n[cpp]\n\nclass HillClimber {\npublic:\nint longest(vector<int>);\n};\nint HillClimber::longest(vector<int> height)\n{\n// The longest sequence of increasing mountains.\nint longest = 0;\n/*\nThere are n+1 mountains, and n segments.\nWe care about increasing segments, which means\nthat mountain i is smaller than mountain i+1.\n*/\n// Keep track of each increasing sequence of mountains in this variable.\nint longestlocal = 0;\n// For each of the first n mountains...\nfor (int i = 0; i < height.size(); i++) {\n// The two mountains we're looking at is the current mountain, and the next one.\nint mount1 = height[i];\nint mount2 = height[i + 1];\n// If mount1 is smaller than mount2, then we're going uphill. Increase longestlocal by 1.\nif (mount1 < mount2) { longestlocal += 1; // Since we had an increase in height, we should check whether this current sequence is longer than "longest" if (longestlocal > longest) {\n// Our longestlocal is the most uphill we've ever seen, so update our longest variable.\nlongest = longestlocal;\n}\n} else { // If the mount1 is bigger than mount2 (or equal), then we aren't going uphill!\n// Reset longestlocal to 0.\nlongestlocal = 0;\n}\n}\nreturn longest;\n}\n\n[/cpp]\n```\n\nThe complexity of our solution is O(N), as we have to visit each segment of a mountain only once. The space complexity for our solution is O(1), as we only need two variables of space (\"__longest__\" and \"__longestlocal__\") to hold the longest uphill sequence.\n\n## TCPhoneHomeEasy\nSRM 722 Round 1 - Division II, Level Two\n\n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14728)\n\n__What is this problem?__\nYou are required to count the number of (digits)-digit integers (let’s call them “good integers”, leading zeros are allowed), for which there are no prefix that is equal to one of the elements of specialPrefixes.\n\nFor example, if digits=3 and specialPrefixes={“1”, “23”, “456”}, the answer is 889. Since there are only 111 integers (“100” to “199”, “230” to “239”, and “456”) for which one of the prefixes is in specialPrefixes, the answer is 1000 – 111 = 889.\nThe Solution\n\nConsider the example where digits=4. What are the integers with the prefix “25”? The answer is all integers between 2500 and 2599.\n\nMore generally, if digits=d, the integers which the prefix s, all integer between l = 10^d-|s| * int(s) and r = 10^d-|s| * (int(s) + 1) – 1 (|s| denotes the length of s, and int(s) denotes the transformation of s from string format to integer).\n\nSo, for each element s in specialPrefixes, you can find l, r for them. The number x is good integer if and only if there are no s which is l ```≤``` x ```≤``` r. Now you can brute-force the value x (the range is 0 ```≤``` x ```<``` 10^digits).\n\nTime Complexity: O(10^digits * K). K equals to number of special prefix.\nMemory Complexity: O(digits * K)\n\n__C++ Code:__\n\n```\n[cpp]\n\n#include <string>\n#include <vector>\nusing namespace std;\nint l[55], r[55];\nclass TCPhoneHomeEasy {\nprivate:\nint power(int a, int b) {\nint ret = 1;\nfor(int i = 0; i < b; i++) {\nret *= a;\n}\nreturn ret;\n}\npublic:\nint validNumbers(int digits, vector<string> specialPrefixes) {\nint n = specialPrefixes.size();\nfor(int i = 0; i < n; i++) {\nstring s = specialPrefixes[i];\nl[i] = power(10, digits - s.size()) * stoi(s);\nr[i] = power(10, digits - s.size()) * (stoi(s) + 1) - 1;\n}\nint all = power(10, digits);\nint answer = 0;\nfor(int i = 0; i < all; i++) {\nbool good = true;\nfor(int j = 0; j < n; j++) {\nif(l[j] <= i && i <= r[j]) good = false;\n}\nif(good) answer++;\n}\nreturn answer;\n}\n};\n\n[/cpp]\n```\n\n## MulticoreProcessingEasy\nSRM 722 Round 1 - Division II, Level Three\n\n- by [kapillamba4](https://profiles.topcoder.com/kapillamba4)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14732)\n\nYou are given 2 arrays of the same size, one represents the speed of computation of a system and other - the maximum number of cores of a system.\n\nA work requires jobLength units of computation and if number of cores utilized is ‘x’ then work gets divided between them as jobLength/x per core\n\ncorePenalty is penalty imposed on computation time for each core utilized beyond one.\nTherefore final formula comes out to be:\n\ncomputationTime = ((jobLength / cores) / speed) + corePenalty*(cores-1)\n\nWe have to choose a system and number of cores to utilize such that total computation time is minimum. We will iterate over each system and its number of cores calculating minimum computation time for each iteration.\n\nWe must return a minimum integer value for computationTime therefore we round up the value of computationTime and return it.\n\nC++Code:\n\n```\n[cpp]\n\n#include <bits/stdc++.h>\nclass MulticoreProcessingEasy {\npublic:\nint fastestTime(int jobLength, int corePenalty, std::vector <int> speed, std::vector <int> cores) {\ndouble ans = 99999999999.0;\nfor(int i = 0; i < speed.size(); i++) {\nfor(int c = 1; c <= cores[i]; c++) {\nans = std::min(ans, ((double)(jobLength)/c)/speed[i]+corePenalty*(c-1));\n}\n}\nreturn std::ceil(ans);\n}\n}\n\n[/cpp]\n```\n\n## TCPhoneHome\nSRM 722 Round 1 - Division I, Level One \n\n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14698)\n\n__What is this problem?__\nYou are required to count the number of (digits)-digit integers (let’s call them “good integers”, leading zeros are allowed), for which there are no prefix that is equal to one of the elements of specialPrefixes.\n\nFor example, if digits=3 and specialPrefixes={“1”, “23”, “456”}, the answer is 889. Since there are only 111 integers (“100” to “199”, “230” to “239”, and “456”) for which one of the prefixes is in specialPrefixes, the answer is 1000 – 111 = 889.\n\nThe integer digits is at most 17.\n\n__The Solution__\nThe digits can be up to 17, so of course you cannot brute-force x. You have to come up with more efficient solution.\n\nThe idea is that, for example, if there’s element “123” and “12345” in specialPrefixes, “12345” has no additional impact on the answer. Generally, suppose if there are element s and t, and s is a prefix of t, t has no meaning. So, you can erase t from specialPrefixes. When there is no meaningless element in specialPrefixes, the answer is 10^digits – (sum of 10^digits-|s| for each element s in specialPrefixes), letting |s| = (length of s).\n\nWhy this way can get the correct answer? Suppose that there is no meaningless element in specialPrefixes. You have to prove that there is no integer x that there are two or more of it’s prefixes in specialPrefixes. If there are two prefixes of x, saying s and t in specialPrefixes, you can say that “s is a prefix of t” or “t is a prefix of s”. It means s or t is a meaningless element, so it makes contradiction.\n\nYou can erase all meaningless element in specialPrefixes in this way:\n1) check there are pair of distinct numbers (x, y) such that specialPrefixes[x] is a prefix of specialPrefixes[y]. If there are no such pair, this is the end of routine.\n2) if there are such pair (x, y), erase specialPrefixes[y] and go back to operation (1).\n\n__Time Complexity:__ O(K^3). K equals to number of special prefixes.\n__Memory Complexity:__ O(K)\n\n__Alternative Solution__\nThe idea is that you can determine integers l and r that the number has prefix s if and only if the number is between l and r. For example, 10-digit integer which has prefix “869120” is, between 8691200000 and 8691209999.\n\nIf you process naively it seems like taking O(10^digits * K) if K is equals to the number of special prefix, and obviously it gets Execution Time Limit Exceeded. But you can use “coordinate compression” technique for this problem and calculate faster.\n\nYou can reduce to the following problem: You are given array l, r with length K. How many (digits)-digit number integer x that there are no integer k that l[k] ≤ x < r[k]. There are at most 2K distinct elements in l and r, so use coordinate compression and you only have to check x for less or equal to these 2K elements. Finally this works in time complexity O(K^2).\n\n__C++ Code__\n\n```\n[cpp]\n\n#include <bits/stdc++.h>\nusing namespace std;\nclass TCPhoneHome {\npublic:\nlong long power(int a, int b) {\nlong long ret = 1;\nfor(int i = 0; i < b; i++) ret *= a;\nreturn ret;\n}\nlong long validNumbers(int digits, vector<string> specialPrefixes) {\nwhile(true) {\nbool found = false;\nfor(int i = 0; i < specialPrefixes.size() && !found; i++) {\nfor(int j = 0; j < specialPrefixes.size() && !found; j++) {\nif(i == j) continue;\nstring s = specialPrefixes[i];\nstring t = specialPrefixes[j];\nif(s == t.substr(0, s.size())) {\n// string t has no meaning\nspecialPrefixes.erase(specialPrefixes.begin() + j);\nfound = true;\n}\n}\n}\nif(!found) break;\n}\nlong long ret = power(10, digits);\nfor(string s : specialPrefixes) ret -= power(10, digits - s.size());\nreturn ret;\n}\n};\n\n[/cpp]\n```\n\n## MulticoreProcessing\nSRM 722 Round 1 - Division I, Level Two \n\n- by [kapillamba4](https://profiles.topcoder.com/kapillamba4)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14699)\n\nYou are given 2 arrays of same size n, one represents the speed of computation of a system and other the maximum number of cores of a system.\n\nA work requires jobLength units of computation and if number of cores utilized are ‘x’ than work gets divided between them as jobLength/x per core.\n\ncorePenalty is penalty imposed on computation time for each core utilized beyond one.\nFor each system we know its computation speed, therefore we can calculate minimum computation time for each system by varying the its number of utilized cores: 1 <= cores <= maximum_cores\nTherefore final formula comes out to be:\n\ncomputationTime = ((jobLength / cores) / speed) + corePenalty*(cores-1);\n\nWe can observe that the above formula represents a familiar graph of\nf(x) = c1/x + c2* x,[ more information here](https://www.wolframalpha.com/input/?i=1%252Fx%252Bx)\n\n![SRM 722](//images.ctfassets.net/piwi0eufbb2g/1o1s5tXqumnutyvRmGOhPg/d3d422a7e01881960576c86d6959a801/SRM_722.webp)\n\nIf we iterate linearly over all systems and overall possible utilized cores values, time complexity will be Θ(Σ(speed[i]* cores[i])) where 0 <= i < n.\n\nHowever we can reduce the time complexity to Θ(Σ(speed[i]* log(cores[i]))) by using ternary search for finding minima for above formula for each system separately.\n\nHere is a good article which explains how ternary search works and here is another good article from TopCoder Cookbook.\n\nWe must return a minimum integer value for computationTime therefore we round up the value of computationTime before returning it.\n\n__C++ Code__\n\n```\n[cpp]\n\n#include <bits/stdc++.h>\nclass MulticoreProcessing {\nconst double eps = 0.00001;\npublic:\ndouble floatMin(long long jobLength, int corePenalty, int speed, double c) {\nreturn ((((double)jobLength)/c)/speed+corePenalty*(c-1));\n}\nlong long longMin(long long jobLength, int corePenalty, int speed, long long c) {\nreturn (((jobLength+c-1)/c+speed-1)/speed+corePenalty*(c-1));\n}\nlong long ternary(long long jobLength, int corePenalty, int speed, int n) {\ndouble r = n, l = 1;\nwhile(fabs(r - l) > eps) {\ndouble m1 = l+(r-l)/3;\ndouble m2 = r-(r-l)/3;\ndouble f1 = floatMin(jobLength, corePenalty, speed, m1);\ndouble f2 = floatMin(jobLength, corePenalty, speed, m2);\nif(f1 > f2) {\nl = m1;\n} else {\nr = m2;\n}\n}\nreturn std::min(longMin(jobLength, corePenalty, speed, floor(l)),\nlongMin(jobLength, corePenalty, speed, ceil(l)));\n}\nlong long fastestTime(long long jobLength, int corePenalty,\nstd::vector <int> speed, std::vector <int> cores) {\nlong long ans = std::numeric_limits<long long>::max();\nfor(int i = 0; i < speed.size(); i++) {\nans = std::min(ans, ternary(jobLength, corePenalty, speed[i], cores[i]));\n}\nreturn ans;\n}\n};\n\n[/cpp]\n``` \n\n## DominoTiling\nSRM 722 Round 1 - Division I, Level Three \n\n- by [asmn](https://profiles.topcoder.com/asmn)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14700)\n\nYou are given a 2D rectangular grid with some cells need to be covered by disjoint 2x1 dominos. Your goal is to calculate the number of ways to do that.\n\nThe idea is to use dynamic programing to do a row by row calculation. For each row r, we only consider placing horizontal dominos covering cells in row r and vertical dominos covering cells in row r and r+1. Use binary number mask to represent the placement of vertical dominos in row r. Placement of vertical dominos in row r-1 and cells don’t need to be covered is represented as binary number pMask and rowMask. In the following figure, mask is (0000101)2, rowMaskis (0100000)2 and pMask is (1000010)2. The tuple (mask, pMask, rowMask) is considered valid if there is a valid dominos placement covering all cells in the row. That means (mask, pmask, rowMask) are all disjoint and the cells uncovered can be covered by horizontal dominos.\n\n![SRM 722 2](//images.ctfassets.net/piwi0eufbb2g/3y16jTU68D4QuKy1r6ueHd/19957b75b0324b3a16224ef9645f5a34/SRM_722_2.webp)\n\nWhen we finish placing dominos in row 0 ~ r-1, let count[r][mask] to be the number of valid ways to fully cover row r with placement mask. The transfer function can be represented as:\nIn a n * m grid, the start condition is count[-1][(00..0)2] = 1, and the final answer is count[n-1][ (00..0)2].\n\nTo speed up calculation, we can perform 2 optimizations:\n1. Instead of checking each (pMask, rowMask[r], mask), we pre calculate all valid mask for each pMask(assuming rowMask[r]=0) by dfs(depth first seach) on all valid placement in a row.\n2. Since we only need row r-1’s information, all previous information can be discarded.\n\n__Python Code__\n\n```\n[cpp]\n\ndef calcT(mask, n):\nret = []\nA = ''.join(('1' if mask & 1 << i > 0 else '0') for i in range(n))\ndef dfs(k, now):\nif k >= n:\nret.append(int(now, 2))\nelse:\ndfs(k + 1, (('0' if A[k] == '1' else '1')) + now)\nif A[k:k + 2] == '00':\ndfs(k + 2, '00' + now)\ndfs(0, '')\nreturn ret\nclass DominoTiling:\ndef count(self, grid):\nn = len(grid[0])\nnMask = 1 << n\nT = [calcT(mask, n) for mask in range(nMask)]\ncountNow = [1] + [0] * (nMask - 1)\nfor row in grid:\ncountNext = [0] * nMask\nrowMask = int(row.replace('.', '0').replace('X', '1'), 2)\nfor pMask in range(nMask):\nif pMask & rowMask > 0:\ncontinue\nfor mask in T[pMask | rowMask]:\ncountNext[mask] += countNow[pMask]\ncountNow = countNext\nreturn countNow[0]\n\n[/cpp]\n```\n\nIt is easily to see that the overall time complexity is O(n* 4^m), where n is number of rows and m is the number of columns. The memory space complexity is O(4^m).","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-722-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3G6BagJ93MlhyYk8xhPMfN","type":"Entry","createdAt":"2020-04-20T12:41:37.132Z","updatedAt":"2026-03-15T12:06:28.473Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":45,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 723","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++"],"creationDate":"2017-12-10T00:00:00.000Z","readTime":"20 min","content":"# Single Round Match 723 Editorials\n\nSome of the SRM 723 Editorials are now published. Thanks to [nitish_](https://profiles.topcoder.com/nitish_) and [kapillamba4](https://profiles.topcoder.com/kapillamba4) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n### SRM 723 Round 1 - Division II, Level Two TopXorerEasy\n### SRM 723 Round 1 - Division I, Level One TopXorer\n- by [nitish_](https://profiles.topcoder.com/nitish_)\n\n[Problem Details TopXorerEasy](https://archive.topcoder.com/ProblemStatement/pm/14737)\n\n[Problem Details TopXorer](https://archive.topcoder.com/ProblemStatement/pm/14736)\n\nTo obtain the answer, we will set all the bits one by one starting from maximum bit.\n\nSuppose integers X = 1xxxxxxxxxxxx (13 bits including 1) and Y = 1xxxxxx . It can be guaranteed that we can at least obtain 111111111111 (12 bits) as the maximum XOR of these numbers. Now, in order to obtain a number greater than this, ee should make use of 13th (1) set bit of X. But when we use that bit, it is not guaranteed that all the bits after that are set to be 1.\n\nThus, in order to check that, we should use the set bit from the smallest available number with us. If there is a number which can contribute to that bit, then use that number. Other numbers which are greater than the smallest number can now be updated to (2^(log2(n)) - 1), because this number will have all the bits as 1 which can be utilised later.\n\nImplementation (Div II Medium):\n\n```\n[cpp]\n\n#include \nusing namespace std;\nclass TopXorerEasy {\npublic:\nint maximalRating(int A, int B, int C) {\nint res = 0;\nint idx = -1;\nvector v;\nv.push_back(A);\nv.push_back(B);\nv.push_back(C);\nfor(int i =30; i >=0; --i)\n{\nidx = -1;\nfor(int j = 0; j < 3; ++j)\n{\nif(v[j]&(1<\nclass SimpleMazeEasy {\nconst long long mod = 1000000007;\npublic:\nlong long power(long long base, int exp) {\nbase %= mod;\nif(exp == 1) return base;\nif(base == 0) return 0LL;\nif(base == 1) return 1LL;\nif(exp == 0) return 1LL;\nif(exp % 2) return (power((base*base)%mod, exp/2)*base)%mod;\nelse return power((base*base)%mod, exp/2);\n}\nint findSum(long long n) {\nreturn ((333333332LL*power(n, 3))%mod + (666666691LL*power(n, 5))%mod)%mod;\n}\n};\n[/cpp]\n\n```\n\n### BuffaloBuffaloBuffalo\nSRM 723 Round 1 - Division I, Level Two \n- by [kapillamba4](https://profiles.topcoder.com/kapillamba4)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14731)\n\nWe are given a string of length ‘n’ consisting of several characters repeated multiple times and ‘?’ character repeated multiple times.\n\nFind in how many ways a valid string of length ‘n’ can be constructed by interleaving several “buffalo” strings together where corresponding characters of valid string and given string match.\n\nNote: The ‘?’ character in given string can match to any character of string “buffalo”\nLet dp[a][b][c][/c][d][e][f] be the number of ways to construct remaining valid string from indices [0 to idx], where\n‘b’ is already repeated a times,\n‘u’ is already repeated b times,\n‘f’ is already repeated c times,\n‘a’ is already repeated d times,\n‘l’ is already repeated e times,\n‘o’ is already repeated f times,\nand a+b+c+d+e+f == n-idx.\n\nHere a ```<=``` b ```<=``` c/2 ```<=``` d ```<=``` e ```<=``` f ```<=``` n/7 equality should always hold true and N should be a multiple of 7 (size of string “buffalo”)\n\nA string is said to be valid/stable if above equalities hold true.\n\n```\n[cpp]\n\n#include \nint dp[15][15][30][15][15][15];\nclass BuffaloBuffaloBuffalo {\nstd::string pat;\nint maxBufalo;\nconst int mod = 1000000007;\nconst std::string bufalo = \"bufalo\";\npublic:\nbool stable(int C[]) {\nif (C['b'] <= C['u'] &&\nC['u'] * 2 <= C['f'] &&\nC['f'] <= C['a'] * 2 &&\nC['a'] <= C['l'] &&\nC['l'] <= C['o'] &&\nC['o'] <= maxBufalo) {\nreturn true;\n} else {\nreturn false;\n}\n}\nint solve(int C[], int idx) {\nif (idx == -1) {\nreturn 1;\n}\nint &ref = dp[C['b']][C['u']][C['f']][C['a']][C['l']][C['o']];\nif (ref != -1) {\nreturn ref;\n}\nif (pat[idx] != '?') {\n++C[pat[idx] + 0];\nint ans = 0;\nif (!stable(C)) {\nans = 0;\n} else {\nans = solve(C, idx - 1);\n}\n--C[pat[idx] + 0];\nreturn (ref = ans);\n} else {\nint ans = 0;\nfor (char c: bufalo) {\n++C[c + 0];\nif (stable(C)) {\nans = (ans + solve(C, idx - 1)) % mod;\n}\n--C[c + 0];\n}\nreturn (ref = ans);\n}\n}\nint count(std::string pattern) {\npat = pattern;\nint A[256];\nmemset(A, 0, sizeof(A));\nmemset(dp, -1, sizeof(dp));\nif (pat.size() % 7 != 0) {\nreturn 0;\n}\nmaxBufalo = pat.size() / 7;\nfor (char c2: pat) {\nbool flag = true;\nfor (char c: bufalo) {\nif (c == c2 || c2 == '?')\nflag = false;\n}\nif (flag) {\nreturn 0;\n}\n}\nreturn solve(A, pat.size() - 1);\n}\n};\n[/cpp]\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-723-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"1xhLLzglb4HBpxKH5Pt6Ye","type":"Entry","createdAt":"2020-04-20T12:41:37.144Z","updatedAt":"2026-03-15T11:51:26.398Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":64,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 724","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++"],"creationDate":"2018-01-18T00:00:00.000Z","readTime":"15 min","content":"# Single Round Match 724 Editorials\n\nSome of the SRM 724 Editorials are now published. Thanks to [square1001](https://profiles.topcoder.com/square1001) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## GravityPuzzleEasy\nSRM 724 Round 1 - Division II, Level One\n\n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details ](https://archive.topcoder.com/ProblemStatement/pm/14742)\n\n__Simple Explanation of Problem__\nThere is a board which is an H by W grid. You are given state of the grid, board. This argument consists from H strings of length W. There is a box in a cell which is in y-th topmost row and x-th leftmost column, if and only if x-th letter of y-th string of board is ‘#’. This board has the gravity, so if there are k boxes on x-th leftmost column, k bottommost cells on this column has a box and others are not. You can see the example of the right (only the red cells has a box.)\n\n__Solution and Approach__\nFirst, you have to count the number of boxes in x-th left column. It means that we have to count “the number of ‘#’ in board[y][x]” for each x. (Let this ccntt[x] for each x.)\nAfter that, you have to get the answer. For doing this, first you have to prepare H string with length W (let this ans), and all of them should be filled with ‘.’. And then, for each x, you have to assign ‘#’ to ans[H – cnt[x]][x], ans[H – cnt[x] + 1][x],…, ans[H – 1][x].\nThat’s all.\n\n![SRM-724-1-300x112](//images.ctfassets.net/piwi0eufbb2g/2YXzgQA81PM8GwO1dkpMtf/11b9f31b5293bfa1d03da01690200bad/SRM-724-1-300x112.webp)\n\nTime Complexity: O(HW)\nMemory Complexity: O(HW)\nSource Code in C++\n\n```\n[cpp]\n\n#include \nusing namespace std;\nclass GravityPuzzleEasy {\npublic:\nvector solve(vector board) {\nint H = board.size(), W = board[0].size();\nvector cnt(W);\nfor (int i = 0; i < W; i++) {\nfor (int j = 0; j < H; j++) {\nif (board[j][i] == '#') {\ncnt[i]++;\n}\n}\n}\nvector ans(H, string(W, '.'));\nfor (int i = 0; i < W; i++) {\nfor (int j = H - cnt[i]; j < H; j++) {\nans[j][i] = '#';\n}\n}\nreturn ans;\n}\n};\n[/cpp]\n```\n\n__Related Problems__\nSRM 724 Division 1 [Medium GravityPuzzle](https://archive.topcoder.com/ProblemStatement/pm/14743) – The problem is in same competition and the problem name is similar, but the problem is completely different. If you are good at competitive programming you can try this problem.\n\n## OrAndSumEasy\nSRM 724 Round 1 - Division II, Level Two \n\n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14745)\n\n__Simple Explanation of Problem__\nFor a given pairOr and pairSum, determine if there is a pair of non-negative integers (a, b) such that “a + b = pairSum” and “the bitwise or of a and b is pairOr”.\nFor example, if pairOr= 7 and pairSum= 11, (a, b) = (5, 6) satisfies the condition. But if pairOr= 7 and pairSum= 24 there are no such (a, b) that satisfies the condition.\nThe value of pairOrand pairSumis between 0 and 1018.\n\n__Solution and Approach__\nLet “x AND y” the bitwise and of x and y, and let “x OR y” the bitwise or of the same. One key observation is, for every non-negative integer x and y, (x AND y) + (x OR y) = x + y stands.\nWhy this is always true? Assume if both x and y is 0 or 1.\n\n| (x, y) | x AND y | x OR y | x + y |\n| ---------- | ---------- | ---------- | ---------- |\n| (0, 0) | 0 | 0 | 0 |\n| (0, 1) | 0 | 1 | 1 |\n| (1, 0) | 0 | 1 | 1 |\n| (1, 1) | 1 | 1 | 2 |\n\nAs you can see from this table, if both x and y is 0 or 1, it is always\n(x AND y) + (x OR y) = x + y\n\nYou can expand to all non-negative integers. For this, let’s use binary notation! Let p the k-th digit (in binary notation) of x and let q the k-th digit (in binary notation) of y. (x AND y) is the sum of (pΛq)x2k and (x OR y) is the sum of (pVq)x2k , and (x + y) is the sum of (p+q)x2k. Therefore, (x + y) – (x AND y) – (x OR y) equals the sum of ((p+q)-(pΛq)-(pVq))x2k=0x2k=0 (since both p and q is 0 or 1, (p + q) – (p AND q) – (p OR q) is always true). Since (x + y) – (x AND y) – (x OR y) = 0, it is obvious to say (x AND y) + (x OR y) = (x + y).\n\nNow, you can reduce to this problem: Is there a pair of non-negative integers (a, b) that satisfies (a AND b) = pairAnd = (pairSum – pairOr) and (a OR b) = pairOr? (For the constraints of problem, pairAnd can be negative)\n\nYou can determine if there is (a, b), by using three following checking conditions.\n1. If pairAnd is negative, obviously there is no (a, b) because (a AND b) is always non-negative.\n2. If there is a non-negative integer k that k-th digit (in binary notation) of pairAnd is 1 and k-th digit (in binary notation) of pairOr is 0, there is no (a, b). You can see that in the table on up has no (x AND y, x OR y) = (1, 0) combination.\n3. Otherwise, the answer always exists because you can set (a, b) = (pairAnd, pairOr).\nYou can determine if condition b satisfies, with judging for each bit. But there are more elegant way. If you pass condition a, you can judge only from setting (a, b) = (pairAnd, pairOr) and check if it is a valid solution.\nIf you use this way, you can write the code simply and can reduce the time complexity to O(1).\nUseful Concepts\nIf you come across the problem which uses bitwise operations, think about the solution that you can divide the problem into one digit in binary notation. If you can do this the problem will be much simple.\n\nAlso, if you want to learn more about problem which uses bitwise operations, see this article - A Bit of Fun: Fun with Bits.\n\nSource code in C++\n\n```\n[cpp]\n\n#include \nusing namespace std;\nclass OrAndSumEasy {\npublic:\nstring isPossible(long long a, long long b) {\nreturn b - a >= 0 && ((b - a) | a) == a ? \"Possible\" : \"Impossible\";\n}\n};\n[/cpp]\n\n```\n\n__Related Problems__\nSRM 724 Division 1 Easy - OrAndSum, the harder version of this problem, which is in Division 1 of the same contest.\n\n## OrAndSum \nSRM 724 Round 1 - Division I, Level One - ## OrAndSum\n\n- by [square1001](https://profiles.topcoder.com/square1001)\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14744)\n\n__Simple Explanation of Problem__\nYou are given two arrays of non-negative integers of length n, pairOrand pairSum. Determine if there is a way to construct a sequence of non-negative integers of length n+1, x0,x1,x2...,xn , that satisfies xiVxi+1=pairOr[i] and xi+xi+1=pairSum[i], for all integer i (0 ≤ i < n). Here, OR denotes the bitwise or. You can assume that n is between 1 and 50, and each element of pairOrand pairSumis between 0 and 1018.\n\n__Solution and Approach__\nLet “x AND y” the bitwise and of x and y, and let “x OR y” the bitwise or of the same. One key observation is, for every non-negative integer x and y, (x AND y) + (x OR y) = x + y stands.\nWhy this is always true? Assume if both x and y is 0 or 1.\n\n| (x, y) | x AND y | x OR y | x + y |\n| ---------- | ---------- | ---------- | ---------- |\n| (0, 0) | 0 | 0 | 0 |\n| (0, 1) | 0 | 1 | 1 |\n| (1, 0) | 0 | 1 | 1 |\n| (1, 1) | 1 | 1 | 2 |\n\nAs you can see from this table, if both x and y is 0 or 1, it is always\n(x AND y) + (x OR y) = x + y\n\nYou can expand to all non-negative integers. For this, let’s use binary notation! Let p the k-th digit (in binary notation) of x and let q the k-th digit (in binary notation) of y. (x AND y) is the sum of (pΛq)x2k and (x OR y) is the sum of (pVq)x2k , and (x + y) is the sum of (p+q)x2k . Therefore, (x + y) – (x AND y) – (x OR y) equals the sum of ((p+q)-(pΛq)-(pVq))x2k=0x2k (since both p and q is 0 or 1, (p + q) – (p AND q) – (p OR q) is always true). Since (x + y) – (x AND y) – (x OR y) = 0, it is obvious to say (x AND y) + (x OR y) = (x + y).\n\nNow you can reduce to this problem. You are given two arrays of non-negative integers of length n, pairAnd and pairOr. Determine if there is a way to construct a sequence of length n+1, x0,x1,x2,....xn that satisfies xiΛxi+1=pairAnd[i](¿pairSum[i]-pairOr[i]) and xiVxi+1 = pairOr[i].\n\nThe condition is only with bitwise operation! Now you can consider each digit in binary notation independently. It means the sequence x exists if and only if sequence x exists when you only consider about k-th (0-origin) digit, for all non-negative integer k.\n\nIt means you can reduce the problem that the elements of pairAnd and pairOr is 0 or 1. The problem is much simple now!\n\nYou can use greedy technique to solve. First, decide the value x0 . Repeat this until all element of x is decided: Suppose if x0,x1,x2,.....,xk is decided. Now, if pairAnd[k] = 1 and pairOr[k] = 0, obviously there is no valid sequence x. Otherwise, you can divide into three conditions:\n\n1. Case of pairAnd[k] = 0 and pairOr[k] = 0. If xk=1, there is no valid sequence x. Otherwise, xk+1=0.\n2. Case of pairAnd[k] = 0 and pairOr[k] = 1. xk+1=1-xk stands.\n3. Case of pairAnd[k] = 1 and pairOr[k] = 1. If xk=0, there is no valid sequence x. Otherwise, xk+1=1.\nYou can determine whether there is a valid sequence x, in time complexity O(n). Since there are no more than 60 bits (≤ log2 pairAnd[k], ≤ log2 pairOr[k]), you can solve this problem efficiently, which is much faster than time limit.\nTime Complexity: O(n log2 max) when max is the maximum among pairSum.\nMemory Complexity: O(n)\n\n__Useful Concepts__\nIf you come across the problem which uses bitwise operations, think about the solution that you can divide the problem into one digit in binary notation. If you can do this the problem will be much simple.\n\nAlso, if you want to learn more about problem which uses bitwise operations, see this article - [A Bit of Fun: Fun with Bits.](https://www.topcoder.com/thrive/articles/A%20bit%20of%20fun:%20fun%20with%20bits)\n\nSource code in C++\n\n```\n[cpp]\nclass OrAndSum {\npublic:\nstring isPossible(vector b, vector s) {\nint n = s.size();\nvector a(n);\nfor(int i = 0; i < n; i++) {\na[i] = s[i] - b[i];\nif((a[i] | b[i]) != b[i]) return \"Impossible\";\n}\nfor(int i = 0; i < 60; i++) {\nvector p(n);\nfor(int j = 0; j < n; j++) {\nif(a[j] & (1LL << i)) p[j] = 2;\nelse if(b[j] & (1LL << i)) p[j] = 1;\nelse p[j] = 0;\n}\nbool flag = false;\nfor(int j = 0; j < 2; j++) {\nint cur = j; bool f = true;\nfor(int k = 0; k < n; k++) {\nif(cur == 0 && p[k] == 2) {\nf = false; break;\n}\nif(cur == 1 && p[k] == 0) {\nf = false; break;\n}\nif(p[k] == 1) cur = 1 – cur;\n}\nif(f) flag = true;\n}\nif(!flag) return \"Impossible\";\n}\nreturn \"Possible\";\n}\n};\n[/cpp]\n\n```\n\n__Related Problem__\nSRM 724 Division 2 Medium - [OrAndSumEasy](https://archive.topcoder.com/ProblemStatement/pm/14745) – the easier version (n=1 version) of this problem.","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"7M4Mi2lee2fNvwwkdUle1b","type":"Entry","createdAt":"2020-04-20T12:41:39.297Z","updatedAt":"2020-04-20T12:41:39.297Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Aditya","tcHandle":"Aditya"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-724-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2yfQOD5yBZXBCqf1L4H4Ff","type":"Entry","createdAt":"2020-04-20T12:41:37.145Z","updatedAt":"2026-03-14T23:35:16.303Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":52,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 726","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++"],"creationDate":"2018-02-07T00:00:00.000Z","readTime":"20 min","content":"# Single Round Match 726 Editorials\n\nSome of the SRM 726 Editorials are now published. Thanks to [OB3LISK](https://profiles.topcoder.com/OB3LISK), [nitish_](https://profiles.topcoder.com/nitish_) and [square1001](https://profiles.topcoder.com/square1001) for contributing to the editorials. If you wish to discuss the problems or editorials you may do it in the discussion forum here.\n\n## StringHalving \n- by [OB3LISK](https://profiles.topcoder.com/OB3LISK)\nRound 1 - Division II, Level One \n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14760)\n\nIn this problem, we have a string where each letter appears exactly twice, and we want to remove the duplicate letters in such a way that the first letter is lexicographically smallest.\nA naive approach is to generate all possible ways of removing the duplicate letters and check which of those ways has the smallest beginning letter. But that's not necessary.\nNotice that, for our string, we're only interested in the characters that can appear in beginning of the string. For a character to appear in the beginning of a string, it must appear before every other character and its duplicate both appear. For example:\nabcddeeabc\n\nWhen we consider the above string, a, b, c, and d can all be characters that appear at the beginning of the string after we remove duplicates. The reason that 'e' can't be chosen is because 'd' shows up twice before 'e' does. That means no matter which 'd' is removed, it will appear before any 'e's can show up.\n\nSo now we know that to solve our problem, we just need to find which characters appear in the string before any other character has its duplicate show up. Then, we can choose the smallest character from that set as our answer.\n\nTo solve this problem, we're going to make use of a frequency array. We create an array where each index represents a character. For example, index 0 represents 'a', index 1 represents 'b', and index 25 represents 'z'. Inside of each of these indices will be a number that represents the number of times we see a particular character.\n\nFor this problem, we'll look at each character in the string, from left to right, updating our frequency array as we go, and once we find a frequency of 2 for any character, we know that we can only choose a letter from the letters we've visited before. We then check our frequency array for the letters we've seen to find which letter was the smallest, and return that as our answer.\n\nThe time complexity for this solution is O(N) (specifically O(N/2 + 1) ), since at worst we have to check half of the letters in our string until we find the duplicate. The space complexity is O(1), since the only extra space we use is a frequency array to represent the count of 26 characters.\n\n__Code:__\n\n```\n[cpp]\n\n#include\n#include\nusing namespace std;\nclass StringHalving\n{\npublic:\nstring lexsmallest(string);\n};\nstring StringHalving::lexsmallest(string s)\n{\nstring answer = \"\"; // The string that we return.\n// Create a frequency array for each character we see.\n// For example, 'a' = index 0, and if it shows up 3 times\n// then freq[0] = 3;\nint freq[26] = {0}; // Initialize each index to 0.\n// Go through each character in our string and mark our frequency array.\nfor(int i = 0; i < s.length(); i++)\n{\nchar c = s[i];\nfreq[c-'a'] += 1;\n// If we find a duplicate (since the letter shows up twice now). Stop checking letters.\nif(freq[c-'a'] == 2)\n{\nbreak;\n}\n}\n// Find which of the letters we found so far is the \"smallest\".\nfor(int i = 0; i < 26; i++)\n{\nchar c = 'a' + i;\n// The first letter we find based on our indexing ('a' = 0 is lowest, 1 is next lowest, etc.)\n// is going to be our best answer.\nif(freq[i] > 0)\n{\nanswer = c;\nbreak;\n}\n}\nreturn answer;\n}\n[/cpp]\n```\n\n(Notice the useful indexing trick used in the code.\n'a' - 'a' = 0\n'b' - 'a' = 1\n'z' - 'a' = 25\n\nYou can easily get the correct index by simply subtracting char variables.)\n\n ## TurtleGame \nby [nitish_](https://profiles.topcoder.com/nitish_)\nSRM 726 Round 1 - Division II, Level Two\n\n[Problem Details](http://archive.topcoder.com/ProblemStatement/pm/14618)\n\nGiven a n x m matrix, and the constraint that a player can move only either down side or right side, the length of the turtle friendly path is fixed, which is (n+m-1).\nIt is given that the board is initially at a turtle friendly path. Because they are playing optimally, we can fix these (n+m-1) blocks and remove everything else. Therefore, if the difference between the number of available blocks and (n+m-1) is Odd, then we return 'Win' else 'Lose'.\n\nComplexity is O(n*m).\n\n__C++ Code:__\n\n```\n[cpp]\n#include \nusing namespace std;\nclass TurtleGame {\npublic:\nstring getwinner(vector board) {\nint valid_moves = 0,n = board.size(),m = board[0].length() ;\nfor(int i =0; i < n; ++i)\n{\nfor(int j = 0; j < m; ++j)\nif(board[i][j] == '.') ++valid_moves;\n}\nint diff = valid_moves - (n+m-1);\nif(diff&1)\nreturn \"Win\";\nelse\nreturn \"Lose\";\n}\n};\n[/cpp]\n```\n\n## HeroicScheduled2\nby [nitish_](https://profiles.topcoder.com/nitish_)\nSRM 726 Round 1 - Division II, Level Three\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14751)\n\nThe problem statement says that you have to find the count of all the possible schedules that can take place. The solution to this problem is greedy + dynamic programming.\n\nFirst, it is wise to first choose a task to do whose deadline is closer. Thus, we will be able to do more number of tasks.\n\nSo, sort the schedules based on the finish time of each schedule.\nThe state of DP will be {index of schedule, bitmask which tracks which day has been used till now}.\n\nThus, if we can find a day vacant between the start[i] and finish[i], then we can schedule that task that day. Or, we can skip that task without scheduling that. Both of the cases increase result by 1.\n\nComplexity: O(N*M), where N = number of tasks and M = 216 (bitmask).\n\n__C++ code:__\n\n```\n[cpp]\n#include \nusing namespace std;\n#define ll long long\nclass HeroicScheduled2 {\npublic:\nint N;\nvector >S;\nll DP[60][1<<16];\nll f(int idx, int mask)\n{\nif(idx == N)\nreturn 1;\nif(DP[idx][mask] != -1)\nreturn DP[idx][mask];\nll res = 0;\nres += f(idx+1, mask);\nfor(int i =S[idx].second; i <= S[idx].first; ++i)\n{\nif(!(mask&(1< start, vector finish) {\nmemset(DP, -1, sizeof DP);\nfor(int i =0; i < start.size(); ++i)\nS.push_back({finish[i], start[i]});\nsort(S.begin(), S.end());\nN = finish.size();\nll ans = f(0,0);\nreturn ans;\n}\n};\n[/cpp]\n```\n\n## Unpacking \n- by [square1001](https://profiles.topcoder.com/square1001)\nSRM 726 Round 1 - Division I, Level One\n\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14759)\n\n__Simple Explanation of Problem__\n\nThere are N boxes which contains red and blue candies. The i-th box has three values: a[i], b[i], and cost[i]. It means, to buy i-th box costs cost[i], and (number of red candies, number of blue candies) = (a[i], b[i]), (a[i]+1, b[i]–1), or (a[i]–1, b[i]+1) are possible. What is the minimum cost if you want to guarantee that you can get at least K candies of same color? If you cannot guarantee even if you buy any set of boxes, answer -1 instead. You can assume, 1 ≤ N ≤ 50, and 1 ≤ a[i], b[i], K ≤ 10000.\nSolution and Approach\n\nFirst, the problem seems complicated. So, let’s think about the following problem instead: “if you buy all boxes, can you guarantee that you can get at least K candies of same color?” Actually, it’s not so hard. You can guarantee that you can get at least K candies if and only if it satisfies one of the three following condition:\n1. The sum of a[i]-1 is at least K.\n2. The sum of b[i]-1 is at least K.\n3. The sum of a[i]+b[i] is at least 2K-1.\n\nYou can prove easily if you take following process. First, take a[i]-1 red candies and b[i]-1 blue candies from each box. Now, there are 2 candies remaining in each box and any color configuration is possible. Then, take all the remaining 2N candies to empty the boxes. Now, for any pair of non-negative integers (x, y) that satisfies x + y = 2N, “you took (sum of a[i]-1)+x red candies and (sum of b[i]-1)+y blue candies” is possible. If you solve the inequalities over the integers, 0≤x≤2N, (sum of a[i]-1)+x\n#include \nusing namespace std;\nconst int inf = 1012345678;\nclass Unpacking {\npublic:\nint solve(vector v, vector c, int K) {\nint N = v.size();\nvector > dp(N + 1, vector(K + 1));\nfill(dp[0].begin() + 1, dp[0].end(), inf);\ndp[0][0] = 0;\nfor (int i = 0; i < N; i++) {\nfor (int j = 0; j <= K; j++) dp[i + 1][j] = dp[i][j];\nfor (int j = 0; j <= K; j++) dp[i + 1][min(j + v[i], K)] = min(dp[i + 1][min(j + v[i], K)], dp[i][j] + c[i]);\n}\nreturn dp[N][K];\n}\nint getcost(vector a, vector b, vector cost, int K) {\nint N = a.size();\nvector v1(N), v2(N), v3(N);\nfor (int i = 0; i < N; i++) {\nv1[i] = a[i] - 1;\nv2[i] = b[i] - 1;\nv3[i] = a[i] + b[i];\n}\nint ret = min({ solve(v1, cost, K), solve(v2, cost, K), solve(v3, cost, 2 * K - 1) });\nreturn ret == inf ? -1 : ret;\n}\n};\n[/cpp]\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"7M4Mi2lee2fNvwwkdUle1b","type":"Entry","createdAt":"2020-04-20T12:41:39.297Z","updatedAt":"2020-04-20T12:41:39.297Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Aditya","tcHandle":"Aditya"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-726-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6rB7ADTnL35WFV0oZEMeDm","type":"Entry","createdAt":"2020-04-20T12:43:24.658Z","updatedAt":"2026-03-10T17:40:05.164Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":113,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 730","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Java"],"creationDate":"2020-04-09T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 730 Editorials\n\n## IntervalIntersections\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14814)\n\nUsed as: Division Two - Level One:\n\n| Field | Value |\n| ---------- | ---------- |\n| __Value__ | 250 |\n| __Submission Rate__ | 235 / 267 (88.01%) |\n| __Success Rate__ | 177 / 235 (75.32%) |\n| __High Score__ | __cnyali_lk__ for 248.75 points (2 mins 1 secs) |\n| __Average Score__ | 202.81 (for 177 correct submissions) |\n\nThere are several cases to consider. We need to check if segments intersect or not.\n\ny1 ```<``` x2: the answer is x2 - x1.\n\ny2 ```<``` x1: the answer is x1 - y2.\n\nOtherwise, segments intersect and the answer is zero.\n\nCode by bohuss:\n\n```\nint ans = 0;\nif(y1= K.\n\nSecond, we will explain how can we deal with the very big numbers. One possible way is to use double (in C++, C#, Java) or long double (in C++) typed variables, which stores real numbers. The double-typed (64-bit) real number variables will assure error of about at most 10^-15 per an arithmetic operation. Here, there are no cases that the probability will be 0.5-x or 0.5+x for very small x like 10^-12, it is okay. The example source code is eriksuenderhauf’s Program written during the contest.\n\nHowever, we can also use big integers. To solve just with integers (not using real numbers), we need to calculate the sum of C(N,i) for all i which holds i*(N-i) = K, and check if the sum (let this be S) is larger than, equal to, or less than 2^N-1.We can calculate S by using Pascal’s triangle, but we can also use the formula C(N,i)+ C(N, i-1) * (N-i+1)/ i and calculate C(N,i) in increasing order of i. This will achieve the time complexity of O(N^2). Here is my implementation in C++. (Since it includes my personal source code library of big integers, the source code size is relatively large)\n\n```\n#ifndef ___CLASS_MODINT\n#define ___CLASS_MODINT\n#include \nusing namespace std;\nstruct MinimizeAbsoluteDifferenceDiv2{\nvector findTriple(int x0, int x1, int x2) {\nint x[3]={x0,x1,x2};\nint p[3]={0,1,2};\nfor(int i=0;i<3;i++)assert(x[i]>=1 && x[i] <=10000);\nvector an(3);\ndouble mi=1e18;\ndo{\ndouble v=fabs(x[p[0]]*1./x[p[1]]-x[p[2]]);\nif(v (p,p+3);\n}\n}while(next_permutation(p,p+3));\nreturn an;\n}\n};\n[/cpp]\n```\n\n## Div II Medium::BulidingSpanningTreeDiv2\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14888)\n\nIn this problem, we are given a complete graph with n nodes, and n-3 “special” edges. We need count the number of spanning trees that contain all of these edges. This is an easier version of the div1 medium.\n\nFirst, if there are any cycles in E, then the answer is zero, since a spanning tree can’t have a cycle.\n\nThe actual topology of E doesn't matter, what matters is the sizes of the connected components it forms. In addition, since E has n-3 edges and no cycles, there will be exactly 3 components left over.\n\nLet the sizes of these components be s_0, s_1, s_2.\nTo form a spanning tree, we must add two more edges. There are three possible edges we can add, of which we need to choose exactly two of them.\n1) We add an edge between s_0, s_1. This can be done in s_0*s_1 ways. (A)\n2) We add an edge between s_0, s_2. This can be done in s_0*s_2 ways. (B)\n3) We add an edge between s_1, s_2. This can be done in s_1*s_2 ways. (C)\n\nThus, the final answer is the sum of products of choosing two of the edges, which is A*B + A*C + B*C = (s_0*s_1) * (s_0*s_2) + (s_0*s_1) * (s_1*s_2) + (s_0*s_2) * (s_1*s_2).\n\nThe time it takes to find the sizes of the components is similar to using Kruskal’s and union find which takes O(n * \\alpha(n)), where \\alpha(n) is the inverse ackermann function.\nDon't forget about the modulo.\n\n__C++ code:__\n[cpp]\n\n```\n#include\n#define SZ(X) (int)((X).size())\nusing namespace std;\nconst int SIZE = 1024;\nconst int MOD = 987654323;\nint d[SIZE],num[SIZE];\nvoid uu(int x,int y) {\nwhile(x != d[x]) x = d[x];\nwhile(y != d[y]) y = d[y];\nif(x == y) return;\nd[x] = d[y];\nnum[y] += num[x];\n}\nstruct BuildingSpanningTreesDiv2{\nint getNumberOfSpanningTrees(int n, vector x, vector y){\nassert(4 <= n && n <= 1000);\nint m = n - 3;\nassert(SZ(x) == m && SZ(y) == m);\nfor(int i = 1; i <= n; i++) {\nd[i] = i;\nnum[i] = 1;\n}\nfor(int i = 0; i < m; i++) {\nassert(1 <= x[i] && x[i] < y[i] && y[i] <= n);\nuu(x[i], y[i]);\n}\nvector gg;\nfor(int i = 1; i <= n; i++) {\nif(d[i] == i) gg.push_back(num[i]);\n}\nif(SZ(gg) != 3) return 0;\nreturn (gg[0] * gg[1] * gg[1] * gg[2] +\ngg[0] * gg[2] * gg[2] * gg[1] +\ngg[1] * gg[0] * gg[0] * gg[2]) % MOD;\n}\n};\n```\n[/cpp]\n\n## Div II Hard::HamiltonianPathsInGraph\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14881)\n\nThis is a classic problem where we want to find a hamiltonian path in a tournament graph. There may already exist some resources online about it (see this link for example: https://math.stackexchange.com/questions/1682492/prove-that-every-tournament-contains-at-least-one-hamiltonian-path). This is an easier version of the div1 hard.\n\nWe will prove an answer always exists by constructing one. We do this by induction.\nFirst, our base case is when n=1, which is just a path with a single node.\n\nNow, consider an arbitrary n > 1, and suppose we have constructed a hamiltonian path of the vertices {0,1,2,..,n-2} and we want to add vertex n-1.\n\nFor each node {0,1,2,...,n-2}, color node i red if there is an edge from i to n-1, otherwise color node i blue if there is an edge from n-1 to i.\n\nSuppose the hamiltonian path on {0,1,2,..,n-2} is p_0, p_1, ..., p_{n-2}.\nIf p_0 is blue, we can append node n-1 to the beginning. If p_{n-2} is red, then we can append node n-1 to the end. So, now let's consider the harder case when p_0 is red and p_{n-2} is blue.\nWe want to find p_i and p_{i+1} such that p_i is red and p_{i+1} is blue.\nThis must exist, since the first node in our path is red, and the last node is blue, so at some point, it must switch from red to blue, at which point we can insert n.\nThus, this shows that we can always extend the hamiltonian path by 1, which completes our induction and gives us an algorithm.\n\nTo implement this, we can follow the steps in our induction above. There are n times where we add nodes, and each of those steps takes O(n) time (O(n) to classify the previous nodes as red or blue, and O(n) time to insert our new node into this list).\n\n__Java Code__\n[java]\n```\nimport java.util.Set;\nimport java.util.HashSet;\npublic\nclass HamiltonianPathsInGraph {\npublic int[] findPath(String[] X) {\nint n = X.length;\nint[] left = new int[128], right = new int[128];\nint start, end;\nint ans[] = new int[n];\nstart = end = 0;\nleft[0] = right[0] = -1;\nfor(int i = 1; i < n; i++) { if(X[i].charAt(start) == '+') { // i->start\nleft[start] = i;\nright[i] = start;\nleft[i] = -1;\nstart = i;\ncontinue;\n}\nif(X[end].charAt(i) == '+') { // end -> i\nright[end] = i;\nleft[i] = end;\nright[i] = -1;\nend = i;\ncontinue;\n}\n// start->i && i->end\nint j = start;\nwhile(X[j].charAt(i) == '+') j = right[j];\n// X[left[j]][i] = '+' & X[i][j] = '+';\nint k = left[j];\nright[k] = i; left[i] = k;\nleft[j] = i; right[i] = j;\n}\nint x = start, idx = 0;\nwhile(x != -1) {\nans[idx] = x;\nidx++;\nx = right[x];\n}\nreturn ans;\n}\n}\n```\n[/java]\n\n## Div I Easy::MinimizeAbsoluteDifferenceDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14883)\n\nIn this problem, you are given five variables a,b,c,d,e and you want to put four of them in the expression |?/? - ?/?| so the resulting value is minimized. This is a harder version of the div2 easy.\n\nThis is an implementation problem. Here, we can try all 5! permutations of replacement, and take the minimum possible value. The time complexity is O(n! * n) where n = 5.\n\n__Java Code:__\n[java]\n```\nclass MinimizeAbsoluteDifferenceDiv1 {\npublic int[] findTuple(int[] x) {\nint[] ans = new int[4];\nlong ans1 = 0, ans2 = 0;\nfor(int i = 0; i < 5; i++) {\nfor(int j = 0; j < 5; j++) {\nif(i == j)continue;\nfor(int k = 0; k < 5 ; k++) {\nif(k == i || k == j) continue;\nfor(int l = 0; l < 5; l++) {\nif(l == i || l == j || l == k) continue;\nlong a = x[i], b = x[j], c = x[k], d = x[l];\nlong f1 = (a*d - c*b), f2 = b*d;\nif(f1 < 0) f1 = -f1;\nif(ans2 == 0 || (ans1*f2 > f1*ans2)) {\nans1 = f1;\nans2 = f2;\nans[0] = i;\nans[1] = j;\nans[2] = k;\nans[3] = l;\n}\n}\n}\n}\n}\nreturn ans;\n}\npublic String checkData(int[] x) {\nif(x == null || x.length != 5)\nreturn \"x must contain exactly five elements.\";\nfor(int i = 0; i < x.length; i++) {\nif(x[i] < 1 || x[i] > 10000) {\nreturn String.format(\"Element \" + i + \" of x must be between 1 and 10,000, inclusive.\");\n}\n}\nreturn \"\";\n}\n```\n[/java]\n\n## Div I Medium::BuildingSpanningTreeDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14880)\n\nIn this problem, you are given a complete graph with n nodes, and some special edges. We want to count the number of spanning trees that contain all of these edges. This is a harder version of the div2 medium.\n\nThis is a classic problem (a similar problem can be found here: \n[http://codeforces.com/problemset/problem/156/D](http://codeforces.com/problemset/problem/156/D)). An editorial (only in russian) can be found here: http://codeforces.com/blog/entry/4005?locale=en, which I’ll briefly summarize. The first few steps are similar as in the div2 solution.\nNamely, if there are any cycles in E, the answer is zero.\n\nOtherwise, the actual topology of E doesn't matter, what matters is the size of each connected component.\n\nLet these sizes be s_0, s_1, ..., s_{k-1}. The answer is (n)^(k - 2) * s_0 * s_1 * … * s_{k-1}.\nThe proof can be seen as a generalization of Caley’s formula on the number of trees with n nodes. You can also see this math stack exchange link for some more information: https://math.stackexchange.com/questions/2550064/proof-of-generalized-cayleys-formula\nThe complexity analysis is similar to div2 medium, where the time is dominated by needing to find the sizes of the components, which is O(n * \\alpha(n)), where \\alpha(n) is the inverse ackermann function.\n\n__C++ code:__\n[cpp]\n```\n#include\n#define SZ(X) (int)((X).size())\nusing namespace std;\nconst int SIZE = 1024;\nconst int MOD = 987654323;\nint d[SIZE],num[SIZE];\nbool uu(int x,int y) {\nwhile(x != d[x]) x = d[x];\nwhile(y != d[y]) y = d[y];\nif(x == y) return 0;\nd[x] = d[y];\nnum[y] += num[x];\nreturn 1;\n}\nstruct BuildingSpanningTreesDiv1{\nint getNumberOfSpanningTrees(int n, vector x, vector y){\nassert(1 <= n && n <= 1000);\nint m = SZ(x);\nassert(SZ(y) == m);\nfor(int i = 1; i <= n; i++) {\nd[i] = i;\nnum[i] = 1;\n}\nset>H;\nfor(int i = 0; i < m; i++) {\nassert(1 <= x[i] && x[i] < y[i] && y[i] <= n);\nassert(H.count(make_pair(x[i], y[i])) == 0);\nif(!uu(x[i], y[i])) return 0;\nH.insert(make_pair(x[i], y[i]));\n}\nvector gg;\nlong long ans = 1;\nint cnt = 0;\nfor(int i = 1; i <= n; i++) {\nif(d[i] == i) {\ngg.push_back(num[i]);\ncnt ++;\nans = ans * num[i] % MOD;\n}\n}\nif(SZ(gg) == 1) return 1;\nfor(int i = 0; i < SZ(gg) - 2; i++) {\nans = ans * n % MOD;\n}\nreturn ans;\n}\n};\n```\n[/cpp]\n\n## Div I Hard::HamiltonianCircuits\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14882)\n\nThis is also a somewhat classic problem where we want to find a hamiltonian circuit in a tournament graph. There may already exist some resources online about it (see this link for example: https://math.stackexchange.com/questions/1682492/prove-that-every-tournament-contains-at-least-one-hamiltonian-path). This is an harder version of the div2 hard.\nAnother approach is as follows.\nLet’s add the nodes in one by one. We will proceed by induction.\n\nAfter each step, instead of maintaining a hamiltonian circuit, we will have a list of hamiltonian circuits for each strongly connected components of the nodes 0,1,2,...,i-1. In addition, since this is a tournament graph, the SCCs from a line from left to right, with all SCC edges in the left pointing to the right.\n\nNow, to add node i, we will find the leftmost SCC that i has an edge to and the rightmost SCC that i has an edge to. Call these SCCs indices A and B respectively.\nIf A > B, then that means we need to insert a new SCC with only node i in between A and B.\nIf A == B, then that means we need to insert node i into SCC A, we can brute force where to insert i (there must exist such an insertion point because there is an edge to and from i in this component).\n\nIf A < B, then we can merge all components from A to B, and also merge their cycles together (we use node i to connect B -> i -> A to make a big cycle). Since we already have cycles in each component, we can rotate each one so that the appropriate node is at the beginning/end.\nAt the end, if there is only one SCC, we can return the cycle of that component, otherwise, return the empty list.\nOne step takes O(n) time, so the overall runtime is O(n^2).\n\n__Python Code:__\n[python]\n```\nclass HamiltonianCircuits():\ndef findCircuit(self, n, seed, a, b, c, d, e):\nvalue = seed\nconn = [[False for j in range(n)] for i in range(n)]\nfor i in range(n):\nfor j in range(i+1, n):\nif value % 1000 <= 250:\nconn[i][j] = True\nconn[j][i] = False\nelse:\nconn[j][i] = True\nconn[i][j] = False\nvalue = (a * value + b) % c\nfor x,y in zip(d,e):\nconn[x][y] = True\nconn[y][x] = False\ncycles = []\nfor add in range(n):\ng1 = -1\ng2 = len(cycles)\nfor ci in range(len(cycles)):\nif any(conn[i][add] for i in cycles[ci]):\ng1 = max(g1, ci)\nif any(conn[add][i] for i in cycles[ci]):\ng2 = min(g2, ci)\nif g1 < g2:\ncycles = cycles[:g2] + [[add]] + cycles[g2:]\ncontinue\nif g1 == g2:\nfor i in range(len(cycles[g1])):\nif conn[cycles[g1][i-1]][add] and conn[add][cycles[g1][i]]:\ncycles[g1] = cycles[g1][:i] + [add] + cycles[g1][i:]\nbreak\ncontinue\na1 = next(i for i in range(len(cycles[g1])) if conn[cycles[g1][i]][add])\na2 = next(i for i in range(len(cycles[g2])) if conn[add][cycles[g2][i]])\npref = cycles[:g2]\nsuff = cycles[g1+1:]\ncycles[g1] = cycles[g1][a1+1:] + cycles[g1][:a1+1]\ncycles[g2] = cycles[g2][a2:] + cycles[g2][:a2]\nmid = []\nfor i in range(g2,g1+1):\nmid.extend(cycles[i])\nmid.append(add)\ncycles = pref + [mid] + suff\nif len(cycles) != 1:\nreturn []\nreturn cycles[0]\n```\n[/python]","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-733-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"x62doCxcQmo96B3lJWiqq","type":"Entry","createdAt":"2020-04-20T12:41:37.420Z","updatedAt":"2026-03-01T23:10:37.685Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":29,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 734","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Java"],"creationDate":"2018-05-18T00:00:00.000Z","readTime":"25 min","content":"# Single Round Match 734 Editorials\n\nThe author of this round and editorial is [Vasyl[alphacom]](https://www.topcoder.com/members/Vasyl[alphacom]). The round was held on 16th May 21:00 UTC-4.\n\n## Div 2 Easy - TheRoundCityDiv2\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14898)\n\nIn this problem we have to count lattice points on a plane that are at most r units far from the origin.\n\nObviously we count only points which both coordinates do not exceed r by an absolute value.\nSince r is at most 100, we can simply iterate over all lattice points (x, y) where -r <= x, y <= r and count such that x^2 + y^2 <= r^2.\nThe time complexity is O(r^2).\n\n## Div 2 Hard - TheRectangularCityDiv2\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14902)\n\nIn this problem you are given a matrix of 0s and 1s.\nYou have to count the number of paths which\n* start at any border cell\n* visit all matrix 0s and no matrix 1s\n* end at any border cell\nSince there are at most 20 matrix cells the problem can be solved using a dynamic programming approach.\n\nWe'll have states with two dimensions:\n* mask - the cell binary mask representing a visited cell set\n* last - the last visited cell\n\nThe state value is the number of ways to visit all the cells represented by the mask and finish in cell last.\nThe transitions between the states can be done by iterating over all neighbours of the last cell.\n\n## Div 1 Easy - TheRoundCityDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14897)\n\nIn this problem we have to count lattice points on a plane that are at most r units far from the origin and are visible from the origin.\n\nA lattice point is visible from the origin if a line segment connecting the point and the origin contains no other lattice points.\nNotice that we can first count only visible lattice points (x, y) such that x > 0 and y >= 0 and then multiply the result by 4.\n\nIt's easy to see that for each visible form the origin lattice point (x, y) gcd(x, y) = 1.\nHere gcd is the greatest common divisor and we assume (x, y) is not at the origin.\nLet's iterate over all x coordinates from 1 to r, inclusive.\n\nThen we find the maximal possible value of y coordinate maxY = floor(sqrt(r^2 - x^2)).\nNow we have to count coprime with x numbers in range [0, maxY].\n\nThis can be done by using inclusion–exclusion principle over all distinct prime divisors of x.\nThe time complexity linearly depends on the total number of prime divisors of integers from 1 to r which is O(r*log(r)).\n\n## Div 1 Medium - TheSquareCityDiv1\n\nThis is a harder version of Div 2 problem TheSquareCityDiv2.\nIn this problem first you have to construct a matrix of integers.\n\nThen for each cell X we find several values:\n1) next(X) - a next cell Y with the maximal value such that a Manhattan distance between X and Y is at most r.\nIf there are multiple such cells you choose the one with the smallest row and then the one with the smallest column.\nIf next(X)=X we call cell X a terminal cell.\n2) d(X) - a destination cell which can be found using the following rules:\n* let d(X) = X;\n* while d(X) is not a terminal cell d(X) = next(d(X)).\n3) cnt(X) - a number of cells Y such that d(Y) = X.\n\nFinally, we have to find the number of cells X such that cnt(X) > 0 and a maximal value of cnt(X) over all cells.\nLet's construct n(X, R) in the same way as next(X) but instead of r we'll use variable R.\nThen next(X) = n(X, r).\n\nIt's easy to see that for each cell X n(X, 0) = X.\nLet X1, X2, X3, X4 are direct neighbours of X, then\nn(X, R+1) = max(n(X1, R), n(X2, R), n(X3, R), n(X4, R)).\n\nThus we can find all values next(X) in O(r * n^2) time.\nNow we have a directed acyclic graph defined by next(X).\nWe can simply find the required values by traversing the graph using dfs or bfs in O(n^2) time.\nThe overall complexity is O(r*n^2)).\n\n## Div 1 Hard - TheRectangularCityDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14901)\n\nThis is a harder version of Div 2 problem TheRectangularCityDiv2.\n\nIn this problem you are given a matrix of 0s and 1s.\nYou have to count the number of paths which\n* start at any border cell\n* visit all matrix 0s and no matrix 1s\n* end at any border cell\n\nThe problem can be solved by dynamic programming with profile.\nThe profile will consist of n or m (which one is smaller) cells.\nCells on one side of the profile have already been visited and they form several (possibly none) partial paths which may connect to each other and should later form a single final path we are looking for.\n\nThe profile configuration describes the way partial paths relate to the profile cells.\nNote that we can have up to 5 partial paths in a profile.\n\nThe state will have a few dimensions:\n* the current cell\n* the profile configuration\n* the number of opened connections (partial path ends) of the current cell (from 0 to 2)\n* the number of the final path ends (from 0 to 2)\n\nThe value is the number of ways to get the given configuration.\nThe transitions between states can be done by iterating over all possible ways how the next cell connects to its neighbours from the current profile (up to 2). Note that the next cell can also be one of the final path ends.","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-734-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4jUKEpAXnaL9nfkJAjsqPb","type":"Entry","createdAt":"2020-04-20T12:41:38.549Z","updatedAt":"2026-03-01T23:03:26.991Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":44,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 735","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Java"],"creationDate":"2018-06-26T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 735 Editorials\n\nIn lieu of the tragic passing of [ltaravilse](https://profiles.topcoder.com/ltaravilse), we ran SRM 735 and TCO18 Round 2C on Tuesday, June 26, 2018 in his honor. \n\n## Div2 Easy: BinaryCalculator\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14930)\n\nIn this problem, you are given a very simple calculator displaying a number. That number can be increased by 3 or decreased by 2 at the press of a button. The goal is to turn a into b using the smallest possible number of button presses.\n\nThere are many possible approaches including a closed form solution, but we outline one that is very simple to code and prove, and thanks to the constraints it is fast enough.\n\nNote that if the current number is larger than b, we need to press the button -2 at least once. Since the operations are commutative, performing this operation right away cannot make matters worse than optimum. Similarly, if the current number is smaller than b, we can press +3 right away. This process can thus be simulated as follows:\n\n```\nclass BinaryCalculator {\npublic:\nint minimumSteps(int a, int b) {\nint ans = 0;\nwhile (a != b) {\nif (a > b) a -= 2;\nelse a += 3;\nans++;\n}\nreturn ans;\n}\n}\n```\n\nThe complexity of this approach is O(|a-b|).\n\n## Div2 Medium: Teleportation Maze\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14946)\n\nIn this task we have a grid representing a maze. There are two types of moves - a quick step towards any of the 4 adjacent cells costing 1 second, or a teleport to the closest empty cell in any of the 4 directions costing 2 seconds. The goal is to find a shortest route from A to B.\nThe limits are small, so one can afford to use any shortest path algorithm, e.g. Dijkstra, to solve it. We present a solution that is faster by a logarithmic factor and is based on BFS. In one BFS iteration, we normally have an array A of vertices to which the distance is d, and use it to construct an array B of vertices at distance d+1. For graphs with unweighted edges, this approach is sufficient. In our problem, we have edges with two different weights: 1 and 2. We can thus modify the BFS to build two arrays at the same time - apart from B already mentioned we construct C containing vertices at distance d+2.\nThe code in C++ is below:\n\n```\nclass TeleportationMaze {\npublic:\nint pathLength(vector a, int r1, int c1, int r2, int c2) {\nint H = a.size();\nint W = a[0].size();\nvector D(H, vector(W, -1));\nD[r1][c1] = 0;\nvector> Aundefined, B, C;\nint time = 0;\nauto checkEdge = [&](int r, int c, int dr, int dc) {\nint nr = r+dr, nc = c+dc;\nwhile (nr >= 0 && nr < H && nc >= 0 && nc < W && a[nr][nc] == '#') { nr += dr; nc += dc; } if (nr >= 0 && nr < H && nc >= 0 && nc < W) { if (nr == r + dr && nc == c + dc) { if (D[nr][nc] > time + 1) {\nD[nr][nc] = time + 1;\nB.push_back({nr,nc});\n}\n} else {\nif (D[nr][nc] > time + 2) {\nD[nr][nc] = time + 2;\nC.push_back({nr,nc});\n}\n}\n}\n};\nwhile (!A.empty() || !B.empty()) {\nfor (auto &p: A) {\nint r = p.first, c = p.second;\ncheckEdge(r, c, 1, 0);\ncheckEdge(r, c, -1, 0);\ncheckEdge(r, c, 0, 1);\ncheckEdge(r, c, 0, -1);\n}\nswap(A,B);\nswap(B,C);\nC.clear();\ntime++;\n}\nreturn D[r2][c2];\n}\n};\n```\n\nThe solution works in O(H W), where H is the number of rows and W is the number of columns.\nSlower solutions, such as ones running in O(H2 W2), could also get accepted.\n\n## Div2 Hard, TCO 2C Medium: MajoritySubarray\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14932)\n\nIn this problem we are given an array a of integers. We are asked to find the number of contiguous subarrays in which there is a number that with more occurrences than half the length of the subarray.\n\nAs the number of possible values in a is rather small (at most 50), we can count the answer separately for every possible value. In other words, for a fixed x, we are asking about the number of subarrays in which x is a majority.\n\nThis is much easier to approach. We process the array from left to right and maintain a current balance, initially b[0] = 0. If a[i] = x, the balance increases by 1, otherwise it is decreased by 1 (i.e. b[i] = b[i-1] ± 1). How do we now count the number of subarrays that end at index i and have x as majority? We can see that this is equal to the number of indices j < i for which b[j] < b[i] - as this means that there are strictly more x’s than non-x’s in the subarray [j,i). This is a very similar problem to counting the number of inversions in an array, and we can use a segment or Fenwick tree to do this fast. Below is a sample implementation in C++.\n\n```\nclass MajoritySubarray {\nvector F;\nint fenwick_sum(int i) const {\nint s = 0;\nwhile (i > 0) { s += F[i]; i -= i & -i; }\nreturn s;\n}\nvoid fenwick_add(int i, int k) {\nwhile (i < (1<<18)) { F[i] += k; i += i & -i; }\n}\npublic:\nll getCount(int N, int seed, int modulo) {\nvector a(N);\nfor (int i = 0; i < N; ++i) { a[i] = (seed>>16) % modulo;\nseed = (seed * 1103515245 + 12345) & 0x7fffffff;\n}\nF.resize(1<<18);\nll ans = 0LL;\nfor (int x = 0; x < modulo; ++x) {\nfill(F.begin(),F.end(),0);\nint bal = N;\nfor (int i = 0; i < N; ++i) {\nfenwick_add(bal, 1);\nif (a[i] == x) ++bal; else --bal;\nans += fenwick_sum(bal-1);\n}\n}\nreturn ans;\n}\n};\n```\n\nNote that for the ease of implementation, the balance in the code starts at N and not from zero as previously mentioned. This is because the Fenwick tree implementation of our choice only accepts non-negative indices. Since we are only ever comparing these balances to each other, this does not change the answer.\nThe complexity of this approach is clearly O(m n log n).\nBonus: Can you do it in O(n log n)?\n\n## Div1 Easy, TCO 2C Easy: PalindromeSubsequence\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14925)\n\nWe are given a string of length at most 50 characters from an alphabet of size 2. We want to partition the string into some subsequences (not necessarily contiguous) such that each such subsequence is a palindrome. Furthermore, we want to use the fewest subsequences possible.\nThis task may look quite intimidating at first. Indeed, for an alphabet had size 3, author is not aware of any polynomial solution. Luckily, we can abuse the fact that there are only two different letters.\n\nIf the string is already palindrome, there is not much left to do. Otherwise, we simply pick all occurrences of ‘a’ as the first string, and all occurrences of ‘b’ as the second. Below is a sample implementation in C++.\n\n```\nclass PalindromeSubsequence {\nbool isPalindrome(string s) const {\nfor (int i = 0; i < s.size()/2; ++i) {\nif (s[i] != s[s.size()-1-i]) return false;\n}\nreturn true;\n}\npublic:\nvector optimalPartition(string s) {\nint N = s.size();\nvector x(N, 1);\nif (!isPalindrome(s)) {\nfor (int j = 0; j < N; ++j) {\nx[j] += s[j] == 'b';\n}\n}\nreturn x;\n}\n};\n```\n\nThe complexity of this approach is O(n), where n is the length of the input.\n\n## Div1 Medium, TCO 2C Hard: QuadraticIdentity\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14924)\n\nWe are given a ring of integers modulo m, and we want to find all a’s from that ring that are invariant to squaring.\n\nAs m is too large, we cannot afford to try all possibilities. Instead, we rewrite a2a (mod m)as a(a-1)=km for some non-negative k. Put differently, it must be true that m divides a(a-1). We can rewrite this fact as a=xcand a-1=yd for some integers x,y and cd=m. Subtracting these two equations we get -xc +yd = 1. This can be solved by Extended Euclidean algorithm. Bézout identity tells us that this has integer solutions for x and y if and only if gcd(c,d) = 1. We can thus run this algorithm for all divisors d of m for which gcd(d,m/d) = 1. In order to find these easily, we can simply factorise to m to prime powers, and then try all possibilities of assigning the factors to c or d. Because of that, that the number of solutions is always a power of 2. As the product of the 14 smallest primes is larger than upper bound on m, there are at most 2^13 solutions.\n\n```\nclass QuadraticIdentity {\nvector factors, answer;\nll M;\nll extended_gcd(ll a, ll b) {\nll s = 0, old_s = 1, t = 1, old_t = 0, r = b, old_r = a;\nwhile (r != 0) {\nll q = old_r / r, z;\nz = old_r; old_r = r; r = z - q * r;\nz = old_s; old_s = s; s = z - q * s;\nz = old_t; old_t = t; t = z - q * t;\n}\nll ans = b*old_t;\nif (ans < 0) ans += M;\nreturn ans;\n}\nvoid generate(ll a, ll b, int i) {\nif (i == factors.size()) {\nanswer.push_back(extended_gcd(a, b));\n} else {\ngenerate(a * factors[i], b, i+1);\ngenerate(a, factors[i] * b, i+1);\n}\n}\nvector getFixedPoints(ll M) {\nthis->M = M;\nll N = M;\nfor (ll i = 2; i*i <= M; ++i) {\nif (N % i == 0) {\nll P = 1;\nwhile (N % i == 0) {\nN /= i;\nP *= i;\n}\nfactors.push_back(P);\n}\n}\nif (N != 1) { factors.push_back(N); }\ngenerate(1, 1, 0);\nsort(answer.begin(),answer.end());\nreturn answer;\n}\n};\n```\n\nThe complexity is O(sqrt(m) + 2^p log m), where p is the number of distinct prime factors of m.\n\n## Div1 Hard: MaxSquare\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14929)\n\nIn this problem, you are given a square matrix, and the goal is to find a square submatrix having the maximum possible sum of elements. The matrix is given in a special format, and it is so big that we cannot even afford to generate it explicitly.\n\nGenerating the vector b from which the matrix A is constructed is a bit of code and carefulness in implementation, but it is something that we can afford. As it will be evident soon, the two-dimensional nature of the problem is a red herring, as there is always an optimal solution perfectly aligned with the main diagonal. We prove that just by manipulating the symbols. Mathematically speaking, we seek the following:\n\nAns = max_{c,x,y} sum_{i=x}^{x+c-1} sum_{j=y}^{y+c-1} b_i + b_j.\nWe can try all possible values of c - the submatrix dimension - and then maximize over all possible c:\nAns = max_c max_{x,y} sum_{i=x}^{x+c-1} sum_{j=y}^{y+c-1} b_i + b_j\nAs b_i does not depend on j, we can take it outside of the inner sum:\nAns = max_c max_{x,y} sum_{i=x}^{x+c-1} (b_i * c + sum_{j=y}^{y+c-1} b_j)\n\nWe can distribute the summation over i and the addition:\nAns = max_c max_{x,y} [ sum_{i=x}^{x+c-1} (b_i * c) + sum_{i=x}^{x+c-1} sum_{j=y}^{y+c} b_j) ]\nSince the latter summand doesn’t depend on i, we can sum it explicitly:\nAns = max_c max_{x,y} [ sum_{i=x}^{x+c-1} (b_i * c) + sum_{j=y}^{y+c-1} (b_j * c) ]\nIt seems that both summands are independent and we can maximise over x and y separately:\nAns = max_c [ max_x sum_{i=x}^{x+c-1} (b_i * c) + max_y sum_{j=y}^{y+c-1} (b_j * c) ]\nThe summands are now equivalent (up to variable names), so their maximiser is the same. Hence:\nAns = 2 max_{c,x} c sum_{i=x}^{x+c-1} b_i\n\nThe sum of b_i can be expressed using prefix sums s, and we can substitute z = x+c:\nAns = 2 max_{x=a and d>=b, then all rectangles using (a,b) are at least as good as those using (c,d), thus (c,d) can be discarded. Using stack, we can find such pruned set of candidates for the bottom-left corner. The same argument with inverted inequality works for the top-right corner.\n\nHaving two sets of points, L and R, we can naively find the maximum area rectangle in O(n^2), but that is of course too slow. The crucial observation is that if the optimal top-right corner for L[i] is R[j], then for all k > j the optimal top-right corner is R[l] where l > j, i.e. the index of the optimal solution is monotone. This can be easily proved by contradiction by drawing a picture and arguing about the sum of areas of rectangles L[i]R[j] and L[k]R[l] versus the sum of L[i]R[l] and L[k]R[j]. This property can be exploited to find the solution in O(n log n) using divide and conquer approach. For details, refer to problem D at http://www.csc.kth.se/~austrin/icpc/finals2017solutions.pdf.\n\nThere is one extra complication though. It may happen that all entries in b are negative. Then the sets L and R are equal, and the above divide-and-conquer solution returns 0 corresponding to an empty matrix. However, the submatrix needs to have size at least 1 (as per the problem statement). In that case, we need to output 2 max b_i instead of zero.\n\nSolution in C++:\n```\nclass MaxSquare {\nvector> L, R;\nvector> normalize(vector> v) {\nvector> ret;\nfor (int i = 0; i < v.size(); i++) { while (ret.size() > 0 && ret[ret.size()-1].second <= v[i].second) {\nret.pop_back();\n}\nret.push_back(v[i]);\n}\nreturn ret;\n}\nvector> invert(vector> v) {\nvector> ret;\nfor (int i = v.size()-1; i >= 0; i--) ret.push_back({-v[i].first, -v[i].second});\nreturn ret;\n}\nll solve(int left, int right, int lo, int hi) {\nint mid = (left+right)/2, bestI = -1;\nll best = -1;\nfor (int i = lo; i < hi; i++) { ll cur = (L[mid].first-R[i].first)*(L[mid].second-R[i].second); if (cur > best) {\nbest = cur;\nbestI = i;\n}\n}\nif (left < mid) {\nbest = max(best, solve(left, mid, lo, bestI+1));\n}\nif (mid+1 < right) {\nbest = max(best, solve(mid+1, right, bestI, hi));\n}\nreturn best;\n}\nvector getB(int n, ull s, int q, int o, vector x, vector y) {\nvector b(n);\nfor (int i = 0; i < n; ++i) { b[i] = (s>>20) % q + o;\ns = (s*25214903917L + 11) & 0x7ffffffffffff;\n}\nfor (int i = 0; i < x.size(); ++i) b[x[i]-1] = y[i];\nreturn b;\n}\npublic:\nll getMaxSum(int n, ll s, int q, int o, vector x, vector y) {\nvector b = getB(n, s, q, o, x, y);\nvector> X;\nll tot = 0;\nX.push_back({0,0LL});\nfor (int i = 0; i < n; ++i) {\ntot += b[i];\nX.push_back({i+1, tot});\n}\nL = invert(normalize(invert(X)));\nR = normalize(X);\nll ans = 2*solve(0, L.size(), 0, R.size());\nif (ans == 0) {\nans = b[0];\nfor (int i = 0; i < n; ++i) {\nans = max(ans, (ll)b[i]);\n}\nans *= 2;\n}\nreturn ans;\n}\n};\n```\n\nWe thought we were looking for the largest square, while in reality, the goal was to find the largest rectangle! The total time complexity is O(n log n).","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6gHA1WnDWUuz1ZtHAncxg3","type":"Entry","createdAt":"2020-04-20T12:42:14.533Z","updatedAt":"2020-04-20T12:42:14.533Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"majk","tcHandle":"majk"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-735-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"5gCnY7ZYi1K6gR7dtgCol6","type":"Entry","createdAt":"2020-04-20T12:41:38.897Z","updatedAt":"2026-03-01T22:49:18.890Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":34,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 736","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Java"],"creationDate":"2018-08-16T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 736 Editorials\n\n## Div2 Easy: A0Paper\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15005)\n\nIn this task, there are many possible solutions. One of them simply greedily combines as many A(i+1) papers into A(i) as possible, for i decreasing. If there are any A0 papers after the process, the answer is clearly “Possible”, otherwise it is “Impossible”. This solution runs in O(n).\n\n```\nclass A0Paper {\nstring canBuild(vector a) {\nfor (int i = a.size()-1; i > 0; --i) a[i-1] += a[i]/2;\nreturn a[0] ? \"Possible\" : \"Impossible\";\n}\n}\n```\n\nAnother possibility is to sum the areas of the papers in stock (multiplied by 2^20, so they are integers instead of doubles). If the total area is at least 1 square meter, it is always possible to build an A0. Keep in mind that 32-bit integers might overflow using this approach.\n\n## Div2 Medium: Reroll\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15004)\n\nThe limits are small enough so that we can try all possible subsets. For each subset, we can calculate the range of values the reroll can produce as the sum of ranges of all individual dice. For a die that is left as is, the range is [a_i, a_i], and for a rerolled die it is [1,6]. If target is inside this range, then it is achievable. This solution works in O(n * 2^n).\nThere is in fact a greedy solution. Without loss of generality let target be larger than the current sum. While this is the case, remove the smallest die and replace it with a 6. Once the current sum is larger or equal to target, we are done. Similarly, if the target is smaller than the current sum, we replace the dice with the largest roll with ones.\n\n```\nclass A0Paper {\nint minimumDice(int target, vector rolls) {\nint N = rolls.size();\nint total = 0;\nfor (int roll: rolls) total += roll;\nsort(rolls.begin(),rolls.end());\nif (target == total) return 0;\nelse if (target > total) {\nfor (int i = 0; i < N; ++i) {\nif (total += 6 - rolls[i] >= target) return i+1;\n}\n} else {\nfor (int i = 0; i < N; ++i) {\nif (total += 1 - rolls[N-i-1] <= target) return i+1;\n}\n}\n}\n}\n```\n\nThe complexity of this approach is O(n log n) or O(n) if sorting counting sort is used.\n\n## Div2 Hard: MazeWithKeys\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14944)\n\nLet’s try all possible starting points, and for each of them we determine whether the target is reachable.\nIf there were no keys, we could have solved the graph using any graph traversal algorithm, such as DFS. How do keys and doors affect the problem? Let’s break down the cases:\n\nWe reach a key k, but we have not visited the door K yet: remember in a global variable (i.e. bitset) that the key k has been found\n\nWe reach the door K, but we have not found the key k yet: remember in a global variable (i.e. bitset) that the door K has been found and do not traverse the neighbours of this vertex\n\nWe reach the door K and a key k has been found: continue the DFS as normal\n\nWe reach a key k and the door K has already been found: start the DFS from the door K\n\nThis algorithm works as the edges are undirected, and thus if a key k and the door K are both reachable, we can always select a path that first visits the key and then the door, thus unlocking the door. The steps above ensure that the DFS continues from the door vertex only after the appropriate key has been found.\nIf we reach the target point from a given start point, we know that such level would be doable, and we can count all the doable levels. Note that all boring levels are also doable, so we just need to subtract the number of boring levels to get the answer.\nTo count the number of boring levels, we run DFS from the target point, ignoring all doors. All reachable cells represent starting points that would create a boring level.\n\n```\npublic class MazeWithKeys {\nvector a;\nint R, C;\nvector doorR, doorC;\nvector hasKey, hasDoor;\nvector> visited;\nbool dfs(int r, int c) {\nif (r < 0 || r >= R || c < 0 || c >= C || visited[r][c]) return false;\nchar w = a[r][c];\nif (w == '#') return false;\nif (w == '*') return true;\nif (w >= 'A' && w <= 'Z') {\nhasDoor[w-'A'] = true;\nif (!hasKey[w-'A']) return false;\n}\nvisited[r][c] = true;\nif (w >= 'a' && w <= 'z') {\nif (!hasKey[w-'a'] && hasDoor[w-'a']) {\nhasKey[w-'a'] = true;\nif (dfs(doorR[w-'a'], doorC[w-'a'])) return true;\n} else {\nhasKey[w-'a'] = true;\n}\n}\nreturn dfs(r+1, c) || dfs(r-1, c) || dfs(r, c-1) || dfs(r, c+1);\n}\nint dfs2(int r, int c) {\nif (r < 0 || r >= R || c < 0 || c >= C || visited[r][c]) return 0;\nchar w = a[r][c];\nif (w >= 'A' && w <= 'Z') return 0;\nif (w == '#') return 0;\nvisited[r][c] = true;\nreturn (w=='.') + dfs2(r+1,c) + dfs2(r-1,c) + dfs2(r,c-1) + dfs2(r,c+1);\n}\nint startingPoints(vector a) {\nthis.a = a;\nR = a.size(); C = a[0].size();\nint ans = 0;\ndoorR = doorC = vector(26);\nvisited = vector>(R, vector(C,false));\nhasKey = hasDoor = vector(26, false);\nfor (int r = 0; r < R; ++r) {\nfor (int c = 0; c < C; ++c) {\nchar w = a[r][c];\nif (w >= 'A' && w <= 'Z') {\ndoorR[w-'A'] = r;\ndoorC[w-'A'] = c;\n} else if (w == '*') {\nans -= reachable(r,c);\n}\n}\n}\nfor (int r = 0; r < R; ++r) {\nfor (int c = 0; c < C; ++c) {\nif (a[r][c] != '.') continue;\nfor (int i = 0; i < 26; ++i) hasKey[i] = hasDoor[i] = false;\nfor (int i = 0; i < R; ++i)\nfor (int j = 0; j < C; ++j) visited[i][j] = false;\nif (dfs(r,c)) ans++;\n}\n}\nreturn ans;\n}\n}\n```\n\nIf we store the locations of all doors in an array so that we don’t have to look for them each time we find a key, simulating one starting point takes O(RC) time, and there are at most O(RC) of them. Hence the total complexity is O(R^2 C^2).\n\n## Div1 Easy: DigitRotation\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14958)\n\nEvaluation of a large integer in modular arithmetic can be done using Horner’s schema in O(N). We can try all possible triples of indices, generate the respective rotated number and sum all evaluations, but that would be too slow. Notice that each rotated number differs from the original number only at most 3 indices. We can thus generate all triples of indices and calculate their difference from the original number. To do that in O(1), we simply need to precompute all powers of 10.\n\n```\nconstexpr int MOD = 998244353;\nclass DigitRotation {\nint sumRotations(string s) {\nint N = s.size();\nvector> W(N, 1);\nfor (int i = N-2; i >= 0; --i) W[i] = 10 * W[i+1];\nField<998244353> sum = 0, ans = 0;\nfor (int i = 0; i < N; ++i) sum = 10 * sum + (S[i]-'0');\nfor (int a = 0; a < N; ++a) {\nfor (int b = a+1; b < N; ++b) {\nfor (int c = b+1; c < N; ++c) {\nif (a == 0 && S[c] == '0') continue;\nint d = S[a]-'0', e = S[b]-'0', f = S[c]-'0';\nauto cur = (f-d)*W[a] + (d-e)*W[b] + (e-f)*W[c];\nans += sum + cur;\n}\n}\n}\nreturn ans;\n}\n}\n```\n\nThe time complexity of the above is O(N^3).\n\n## Div1 Medium: MinDegreeSubgraph\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/14951)\nThe smallest graph (in terms of the number of edges) that is locally k-dense is a clique on k+1 vertices. Thus, if m ```<``` k(k+1)/2, the answer is clearly NONE.\nBy induction on n we can prove that all graphs having m ```>=``` t(n,k) := k(k+1)/2 + (n-(k+1))(k-1) edges are localy k-dense. The base case where n = k+1 is trivial, as it is a k+1-clique. Consider a graph G with ```>```k+1 vertices and let v be the vertex of minimum degree. If deg(v) >= k, we are done. Otherwise, remove v from G to form G’. G has n’ = n - 1 vertices and at least m’ >= m - (k-1) ```>=``` k(k+1)/2 + (n’-(k+1))(k-1) = t(n’,k) vertices. By induction, G’ is locally k-dense.\nOn the other hand, for m ```<``` t(n,k) we can construct a graph G with n vertices, m edges and no mindegree k subgraph. Clearly it suffices to show that there is such graph with t(n,k) - 1 edges, as graphs with fewer edges can be obtained simply by removing edges. Start with a (k-1)-clique on vertices 1,..,k-1. Connect each vertex with index k,..,n to each of the vertices 1,..,k-1. There are exactly t(n,k)-1 edges in this graph. Additionally, there are only k-1 vertices with degree at least k, so G is not locally k-dense.\n\nThis means that if m ```<``` t(n,k), the answer is SOME and if m ```>=``` t(n,k), the answer is ALL.\n\n```\nclass MinDegreeSubgraph {\nstring exists(int n, ll m, int k) {\nif (m < ll(k) * (k+1) / 2) return \"NONE\";\nelse if (m < ll(k) * (k+1) / 2 + ll(n - (k+1))*(k-1)) return \"SOME\";\nelse return \"ALL\";\n}\n}\n```\n\nThe time complexity is O(1).\n\n## Div1 Hard: Subpolygon\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14952)\n\nIt is evident that as P is convex, each choice of W yields a different convex polygon Q. We need to sum the areas across all such polygons.\n\nRecall that one can compute the area of the polygon as half of the sum of X[i]*Y[i+1] - X[i+1]*Y[i], where (X[0],Y[0]), (X[1],Y[1]), ... , (X[M],Y[M]) = (X[0],Y[0]) are the coordinates of vertices in counter-clockwise order.\n\nConsider an edge between P[i] and P[i+j] separately. If we knew the number of subpolygons in which it appears, we could calculate its contribution towards the sum of areas. In order for this edge to appear in Q, none of the vertices of the form P[i+k] (0 < k < j) may be present in Q, and at least one of the vertices of form P[i+k] (j ```<``` k ```<``` N) has to be present in Q (so that Q does not degenerate to a line segment). There are thus 2^{N-j-1}-1 such polygons.\n\nIf we precompute all powers of 2, we can compute the sum of areas in O(n^2). To make this faster, note that the total area is, up to some multiplicative factors, a sum of two convolutions and can be thus computed with FFT.\n\nIn the sample source below, the FFT implementation is omitted for brevity. Also note that the template class Field is used for modular arithmetic (i.e. performing all additions, subtractions and multiplication modulo given prime, and using modular exponentiation for division).\n\n```\nclass Subpolygon {\npublic:\nint sumOfAreas(int n) {\nvector> x(8*n), y(8*n), revX(8*n), revY(8*n);\n// generate polygon P\nfor (int i = 0; i < n; ++i) {\nx[i+1] = x[i] + (n-i);\ny[i+1] = y[i] + i;\n}\nfor (int i = 0; i < n; ++i) {\nx[n+i+1] = x[n+i] - i;\ny[n+i+1] = y[n+i] + (n-i);\n}\nfor (int i = 0; i < n; ++i) {\nx[2*n+i+1] = x[2*n+i] - (n-i);\ny[2*n+i+1] = y[2*n+i] - i;\n}\nfor (int i = 0; i < n; ++i) {\nx[3*n+i+1] = x[3*n+i] + i;\ny[3*n+i+1] = y[3*n+i] - (n-i);\n}\n// concatenate x (resp. y) with itself, and let revX,revY be reverse of x,y\nfor (int i = 0; i < 4 * n; ++i) {\nx[4*n+i] = revX[4*n-1-i] = x[i];\ny[4*n+i] = revY[4*n-1-i] = y[i];\n}\n// convolve x with revY, y with revX\nfft(x); fft(y); fft(revX); fft(revY);\nfor (int i = 0; i < x.size(); ++i) {\nx[i] *= revY[i];\ny[i] *= revX[i];\n}\nfftInverse(x); fftInverse(y);\n// calculate answer\nField<998244353> ans = 0, p = 1;\nfor (int i = 8*n-3; i >= 4*n; --i) {\nans += p*(y[i]-x[i]);\np = 2*p+1;\n}\nreturn ans/2;\n}\n};\n```\n\nThe total complexity is O(n log n).","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6gHA1WnDWUuz1ZtHAncxg3","type":"Entry","createdAt":"2020-04-20T12:42:14.533Z","updatedAt":"2020-04-20T12:42:14.533Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"majk","tcHandle":"majk"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-736-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nJj6kyJhu8z0zKQqDFlB1","type":"Entry","createdAt":"2020-04-20T12:42:12.814Z","updatedAt":"2026-03-01T22:40:15.945Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":44,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 739","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Java"],"creationDate":"2018-10-10T00:00:00.000Z","readTime":"30 min","content":"SRM 739 was held on October 10th. Thanks to [Blue.Mary](https://www.topcoder.com/members/Blue.Mary) for the problems and [majk](https://www.topcoder.com/members/majk) for testing the round and writing the editorials.\n\n## HungryCowsEasy - Div. 2 Easy\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15099)\n\nThe limits are small, so we can afford iterating over all cow-barn pairs. For each such pair, we calculate the cow’s distance from the barn. For a fixed cow, we select the barn with the smallest distance. There can be at most two such barns, and if there are two, we pick the one with smaller x-coordinate.\n\n```\nclass HungryCowsEasy {\npublic:\nvector findFood(vector cowPositions, vector barnPositions) {\nvector ans;\nfor (int cow: cowPositions) {\nint best = 0;\nfor (int i = 0; i < barnPositions.size(); ++i) { int curPos = barnPositions[i]; int bestPos = barnPositions[best]; if (abs(curPos-cow) > abs(bestPos-cow))\nbest = i;\nif (abs(curPos-cow) == abs(bestPos-cow) && curPos < bestPos))\nbest = i;\n}\nans.push_back(best);\n}\nreturn ans;\n}\n};\n```\n\nThe complexity of this approach is O(n^2). It can also be solved in O(n log n) or even in O(n) if both arrays would be initially sorted.\n\n## ForumPostMedium - Div. 2 Medium\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15095)\n\nWe start by converting the timestamps into a format that is easier to work with: the number of seconds from the midnight. Consider the difference between the two timestamps. We can observe that each potential label is used on a single interval. One can thus use few simple if statements.\n\nOne slight complication is that the post might be from a previous day. In that case, the number of seconds between the (yesterday’s) midnight and the posting time is larger than the number of seconds between the (today’s) midnight and the current time. In that case, we need to add 86400 (the number of seconds in a day) to the difference.\n\n```\nclass ForumPostMedium {\npublic:\nstring getShownPostTime(string currentTime, string exactPostTime) {\nstringstream ct(currentTime), ept(exactPostTime);\nint h, m, s; char c, d;\nct >> h >> c >> m >> d >> s;\nint t1 = 3600*h + 60*m + s;\nept >> h >> c >> m >> d >> s;\nint t2 = 3600*h + 60*m + s;\nint diff = t1 - t2;\nif (diff < 0) diff += 24 * 60 * 60;\nif (diff < 60) return \"few seconds ago\";\nelse if (diff < 60 * 60) {\nstringstream ans;\nans << diff / 60 << \" minutes ago\";\nreturn ans.str();\n} else {\nstringstream ans;\nans << diff / 60 / 60 << \" hours ago\";\nreturn ans.str();\n}\n}\n};\n```\n\nThe complexity of this approach is O(1).\n\n## CheckPolygon - Div. 2 Hard\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15098)\n\nIn this task, one needs to carefully translate the requirements from words into code. To prevent any nasty surprises, we should perform all computations on integers, and avoid floats.\nFirst, a few definitions:\n\n```\ntypedef pair Point;\n#define x first\n#define y second\n```\n\nWe use a simple orientation test, that returns positive value for left hand turn, negative value for right hand turn, and zero for collinear points.\n\n```\n\nint orientation(Point a,, Point b, Point c) {\nauto o = (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x);\nreturn (o>0) - (o```<```0);\n}\nbool collinear(Point a, Point b, Point c) {\nreturn orientation(a, b, c) == 0;\n}\n\n```\n\nNext we need a test to check whether a point lies on segment. To check that, all three points must be collinear, and both the x and y-coordinates of the point on the segment has to be within the bounding box of the segment:\n\n```\n\nbool onSegment(Point a, Point b, Point c) {\nreturn orientation(a, c, b) == 0\n&& ((c.x <= max(a.x, b.x) && c.x >= min(a.x, b.x))\n&& (c.y <= max(a.y, b.y) && c.y >= min(a.y, b.y)));\n}\n\n```\n\nTo determine whether two segments intersect, we first check whether any of the four points lies on the other segment. Then, we can use the fact that the segments intersect if and only if the points a and b are in different half-planes determined by the line cd, and the points c and d are in different half-planes determined by the line ab. This condition is easily checked using orientation tests:\n\n```\nbool segmentsIntersect(Point a, Point b, Point c, Point d) {\nreturn onSegment(a, b, c) || onSegment(a, b, d)\n|| onSegment(c, d, a) || onSegment(c, d, b)\n|| (orientation(a, b, c) != orientation(a, b, d)\n&& orientation(c, d, a) != orientation(c, d, b))\n}\n```\n\nNext we need a method to calculate the area. Since all the points are at integer coordinates, the area is an integer or a half of an integer, so we can again perform all calculations in integers.\n\n```\n\nll doubleSignedArea(int N, vector P) const {\nll area = 0;\nfor (int i = 0; i < N; ++i) area += P[i].x * P[i+1].y - P[i+1].x * P[i].y;\nreturn area;\n}\n\n```\n\nAnd now we put everything together. We verify two things:\nNo three consecutive points are collinear\nNo two non-consecutive line segments intersect.\nIf both conditions are satisfied we report the area.\n\n```\nclass CheckPolygon {\npublic:\nstring check(vector X, vector Y) {\nint N = X.size();\nvector P(N+2);\nfor (int i = 0; i < N; ++i) P[i] = {X[i], Y[i]};\nP[N] = P[0]; P[N+1] = P[1];\nfor (int i = 0; i < N; ++i) {\nif (collinear(P[i], P[i+1], P[i+2])) return \"Not simple\";\nfor (int j = i+2; j < N; ++j) {\nif (i == 0 && j == N-1) continue;\nif (segmentsIntersect(P[i], P[i+1], P[j], P[j+1]))\nreturn \"Not simple\";\n}\n}\nll area = abs(doubleSignedArea(N, P));\nstringstream s;\ns << area/2 << '.' << \"05\"[area%2];\nreturn s.str();\n}\n};\n```\n\nThe complexity of this approach is clearly O(n^2).\n\n## ForumPostEasy - Div. 1 Easy\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/15096)\nThe obvious thing to do in this task is to try every possible starting time and see whether it matches the observations. The property of being the lexicographically smallest time equals to being the closest time to midnight. Note that we should parse the input just once to avoid having too large constant in the time complexity.\n\n```\nclass ForumPostEasy {\npublic:\nstring getCurrentTime(vector exactPostTime, vector showPostTime){\nvector Times, Result;\nfor (int i = 0; i < exactPostTime.size(); ++i) { stringstream ept(exactPostTime[i]); int h, m, s; char c, d; ept >> h >> c >> m >> d >> s;\nint t = 3600*h + 60*m + s;\nTimes.push_back(t);\nchar ch = showPostTime[i][showPostTime[i].size()-6];\nif (ch == 'd') Result.push_back(0);\nelse {\nstringstream spt(showPostTime[i]);\nint d; spt >> d;\nif (ch == 'e') Result.push_back(d);\nelse Result.push_back(-d);\n}\n}\nfor (int t = 0; t < 86400; ++t) {\nbool ok = true;\nfor (int i = 0; i < exactPostTime.size() && ok; ++i) {\nint exp = 0, diff = t - Times[i];\nif (diff < 0) diff += 86400; if (diff >= 3600) exp = -(diff / 3600);\nelse if (diff >= 60) exp = diff / 60;\nok &= exp == Result[i];\n}\nif (ok) {\nstringstream ans;\nans << t / 36000 << (t / 3600)%10 << ':'\n<< (t / 600)%6 << (t / 60)%10 << ':' << (t / 10) % 6 << t%10;\nreturn ans.str();\n}\n}\nreturn \"impossible\";\n}\n};\n```\n\nThe complexity of this approach is O(t n), where t is the number of seconds in a day.\n\n## HungryCowsMedium - Div. 1 Medium\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15100)\n\nWe can binary search on the answer. How do we check whether the cows can make it in time? First note that if cow has appetite a_i and a barn has coordinate x_j, then the cow cannot possibly eat at this barn if a_i + x_j``` >``` t. For this reason, we sort all the barns by their increasing coordinate, and all cows by their decreasing appetite and use the following greedy algorithm.\n\nWe pick k such that sum_i=1^k a_i ```<=``` t - x_1. Then k of the cows with the most appetite will eat their full portion in the first barn. If there is time left in this barn, we take the k+1-th cow and use the remaining capacity. To have the maximum flexibility, it is clear that this is the first cow that should eat. In the next barn, this half-fed cow needs to eat last, and reduces the capacity accordingly.\n\nTo show that this strategy is indeed optimal, one needs to use the exchange argument to show that we can avoid the following configurations in an optimal solution:\na cow that eats at both i-th and j-th barn where j-i >= 2\n\ntwo cows that eat at both i-th and i+1-th barn\ncows a_i ```>``` a_j eating (at least partially) at barns x_k ```>``` x_l, respectively\n\n```\nclass HungryCowsMedium {\npublic:\nll getWellFedTime(vector C, vector B) {\nsort(C.begin(),C.end());\nsort(B.begin(),B.end());\nreturn binary_search_smallest(0LL, ll(4e11), [&](ll T) {\nauto cow = C.rbegin(); ll time = 0;\nfor (auto barn = B.begin(); barn != B.end() && cow != C.rend(); ++barn) {\nif (*cow > T - *barn) return false;\ntime += T - *barn - *cow;\nwhile (++cow != C.rend() && *cow <= time) time -= *cow;\n}\nreturn cow == C.rend();\n});\n}\n};\n```\n\n## MakePolygon - Div. 1 Hard\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15097)\n\nA bit of trial and error suggests that on an infinite grid, the optimal solution has area (N-2)/2. The question is how to put it into a grid that is relatively small, and how to avoid the neighbouring segments to be collinear. One approach would be to make an inward spiral, such as this one with 572 points, built from blocks of 8 points in a 2x5 rectangle.\n\nIf fewer than 500 points are requested, we may omit some of the points from either side. Keep in mind that this may introduce two collinear consecutive segments, i.e. when we remove the four points at the inner end of a spiral. To combat this, we may either remove some points from both ends of a spiral and check whether the conditions hold, or we may be more careful in the spiral construction. The approach used in the solution below is to not generate all the six points in a rectangle if we are approaching the correct number of points.\n\nTo do that in a manageable fashion, we grow two sides of the polygon, called left and right, in alternating fashion, and stop when the needed amount of points is reached. Afterwards, the left and right side of the polygon are merged together.\n\n```\nclass MakePolygon {\npublic:\nint N;\nvector L, R;\nbool space(int n = 0) {\nreturn (L.size() + R.size() + n< N); } void left(int x, int y) { if (space() && (L.empty() || L.back() != 100*x+y) && x >= 1 && x <= 25 && y >= 1 && y <= 25) L.push_back(100*x+y); } void right(int x, int y) { if (space() && (R.empty() || R.back() != 100*x+y) && x >= 1 && x <= 25 && y >= 1 && y <= 25) R.push_back(100*x+y);\n}\nvoid yway(int x, int y, int d, int end) {\nbool beg = true;\nwhile (y != end) {\nleft(x, y);\nright(x+d, y);\nif (!beg && space(4)) left(x-d, y);\nif (!beg && space(3)) left(x, y+d);\nif (!beg && space(5)) right(x+d+d, y);\nif (!beg && space(5) && y+d+d != end) right(x+d+d+d, y+d);\nleft(x+d, y+d);\nright(x+d+d, y+d);\ny += d+d;\nbeg = false;\n}\n}\nvoid xway(int x, int y, int d, int end) {\nbool beg = true;\nwhile (x != end) {\nif (!beg && space(4)) right(x, y-d-d);\nif (!beg && space(4)) left(x, y+d);\nleft(x, y);\nright(x, y-d);\nright(x+d, y-d-d);\nif (!beg && space(5) && x+d+d != end) right(x+d, y-d-d-d);\nleft(x+d, y-d);\nif (space(4)) left(x+d, y);\nx += d+d;\nbeg = false;\n}\n}\nvector make(int N) {\nthis->N = N;\nfor (int j = 0; j <= 8; j += 4) {\nyway(1+j, 1+max(j-2,0), 1, 25-j); left(2+j, 25-j);\nxway(3+j, 25-j, 1, 25-j); left(25-j, 24-j);\nyway(25-j, 23-j, -1, 1+j); left(24-j, 1+j);\nxway(23-j, 1+j, -1, 5+j); left(5+j, 2+j);\n}\nreverse(L.begin(),L.end());\nL.insert(L.end(), R.begin(), R.end());\nreturn L;\n}\n};\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6gHA1WnDWUuz1ZtHAncxg3","type":"Entry","createdAt":"2020-04-20T12:42:14.533Z","updatedAt":"2020-04-20T12:42:14.533Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"majk","tcHandle":"majk"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-739-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3oeSsmUsDt8LeAmX5f41he","type":"Entry","createdAt":"2020-04-20T12:42:12.906Z","updatedAt":"2026-03-01T22:26:06.923Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":47,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 741","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Python","Java"],"creationDate":"2018-10-31T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 741 Editorials\n\nSRM 741 was held on 30th October. The problem set was prepared by [Blue.Mary](https://profiles.topcoder.com/Blue.Mary). Thanks to [misof](https://profiles.topcoder.com/misof) for testing and preparing the editorials. This was the last SRM in stage 1 of TCO19 Algorithm Qualification. Congratulations to [tourist](https://profiles.topcoder.com/tourist) for qualifying for TCO19 Algorithm Finals!\nMatch Result and Overview.\n\n## DigitStringDiv2\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15143)\n\nAs is usually the case in the easy problem in Division 2, the constraints are so small that any correct solution will pass. And as is usually the case, the easiest way to write a correct solution is to use brute force.\n\nIn this problem, brute force looks as follows: We’ll generate all possible substrings of S. We can do this simply by trying all possibilities for the indices of its beginning and end. For each of the substrings, we will check whether it starts with a non-zero digit, and then we convert it to an integer and compare it to X.\n\nIn order to convert a string to an integer, you can either use a built-in function (most languages will have one), or you can iterate over the string one character at a time, as follows:\n\n```\ndef string_to_int(S):\n answer = 0\n for c in S:\n answer = 10*answer + ord(c) - ord('0')\n return answer\n```\n\nHere is a full working implementation:\n\n```\ndef count(S,X):\n\n answer = 0\n\n for z in range( len(S) ):\n\n for k in range( z+1, len(S)+1 ):\n\n N = S[z:k]\n\n if N[0] == '0': continue\n\n if int(N) > X: answer += 1\n\n return answer\n```\n\n## SimpleMathProblemDiv2\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15147)\n\nThe function value f(n) is defined as the sum of g(n,p) over all primes p. However, if p > n, then clearly p does not divide n, which means that g(n,p) is zero. Thus, when computing f(n) we only care about primes that are less than or equal to n.\n\nThe most straightforward way to solve this task was to actually compute the functions f and g as specified in the statement. Computing g is easy: we simply compute powers of p until we are about to exceed n. This runs in O(log n) time, which is very fast. (In the worst case, for n=444,777 and p=2, the function will still make fewer than 20 iterations.)\n\n```\nlong long g(long long n, long long p) {\n\n // assumes that we already checked that p divides n\n\n long long answer = 1;\n\n while (answer * p <= n) answer *= p;\n\n return answer;\n\n}\n\n```\n\nNow we need to implement f. In order to compute f(n), we need to sum all non-zero g(n,p). In other words, we need to find all primes p that divide n, and we need to compute g for each of them. How can we do that quickly?\n\nOne simple way to find all prime factors of n (and, in fact, the full factorization of n) is to use one simple observation: Among all the primes in n’s prime factorization there can be at most one that is bigger than the square root of n. Why? Because already if you take two such primes, their product is obviously more than n.\n\nBased on this observation, we can now write the following implementation of f:\n\n```\nlong long f(int n) {\n\n long long answer = 0;\n\n int original_n = n;\n\n for (int d=2; d*d <= n; ++d) {\n\n if (n % d == 0) {\n\n while (n % d == 0) n /= d;\n\n answer += g(original_n,d);\n\n }\n\n }\n\n if (n > 1) answer += g(original_n,n);\n\n return answer;\n\n}\n```\n\nIf we don’t count the calls to g, this implementation of f obviously runs in O(sqrt(n)). Thus, for any n ```<=``` 444,777 it will only require at most sqrt(444,777) <= 667 iterations, and usually it will be even fewer than that.\n\nTwo things to note in the above implementation: First, whenever we find a d that actually divides n, we can be sure that this must be a prime number. It cannot be the product of smaller prime numbers, because we already tried all of those and we divided n by each of those, so the current value of n isn’t divisible by anything smaller than d. Second, note that the value of n changes during the computation, and that new, smaller n is then used as the upper bound for the cycle. This is still correct, because the same argument still applies: the value that remained in n is either a prime, or it still has a divisor that is at most equal to its own square root.\n\nTo finish the solution, we now just run a simple for-cycle to compute the sum f(1) + … + f(X).\n\nAnother reasonably simple solution is based on the following steps:\n\nUse the [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes) (or a primality test similar to the algorithm used above) to generate all primes up to X.\n\nFor each prime p in that set, go through n=p, 2p, 3p, … until you reach X, and for each such n compute g(n,p) and add it to the total.\n\nThere are much faster solutions, but those were not needed to get accepted in the Division 2 version of this problem. If you want to see them, one will be presented below.\n\n## BoardCoveringDiv2\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15145)\n\nThe main observation needed to solve this problem is that regardless of the shape and orientation of a tromino, its perimeter is always 8. Hence, each tromino is adjacent to at most 8 other unit squares. And as we have 10 available colors, we can color the trominoes greedily. More precisely, we can do the following:\n\n```\nfor each tromino on the given board (in any order):\n\n look at the colors already used on squares adjacent to this tromino\n\n pick a color that is not among them\n\n use that color for this tromino\n\n```\n\nAll that remains is to implement the above algorithm in a painless way. Let’s do one more iteration of writing pseudocode, but now with more details.\n\n```\nfor each row r:\n\n for each column c:\n\n if the square at (r,c) belongs to an uncolored tromino:\n\n find the rest of the tromino\n\n find all squares adjacent to those\n\n collect all their colors, etc.\n```\n\nIn order to find the rest of the tromino, we can use any standard graph search (e.g., BFS or DFS), but I opted for a different technique: I wrote a function that would generate all adjacent cells to a given cell by simply trying all four directions. Then, you can generate the tromino by essentially iterating this function twice. More precisely, you take all the neighbors of the original cell that share the same color in the input, and then you take all their neighbors with the same property, and you have the tromino. As a bonus, you can then use the same function in the next step, only now you take the cells that had a different color in the input.\n\nFull implementation:\n\n```\ndef neighbors(board, r, c, same=True):\n\n '''\n\n if \"same\", returns neighbors of the square (r,c) that have the same color\n\n otherwise, returns neighbors of the square (r,c) that have another color\n\n '''\n\n answer = set()\n\n for nr, nc in [ (r-1,c), (r+1,c), (r,c-1), (r,c+1) ]:\n\n if not (0 <= nr < len(board) and 0 <= nc < len(board[0])):\n\n continue\n\n if same:\n\n if board[r][c] == board[nr][nc]: answer.add( (nr,nc) )\n\n else:\n\n if board[r][c] != board[nr][nc]: answer.add( (nr,nc) )\n\n return answer\n\ndef spread(board, cells, same=True):\n\n '''\n\n if \"same\", returns the cells from \"cells\" + their same-color neighbors\n\n otherwise, returns the other-colored neighbors of cells from \"cells\"\n\n '''\n\n new_cells = cells.copy() if same else set()\n\n for r,c in cells: new_cells |= neighbors(board,r,c,same)\n\n return new_cells\n\ndef get_tromino(board, r, c):\n\n cells = set([ (r,c) ])\n\n cells = spread(board, cells)\n\n cells = spread(board, cells)\n\n return cells\n\ndef make(board):\n\n R, C = len(board), len(board[0])\n\n digits = '0123456789'\n\n answer = [ [ None for c in range(C) ] for r in range(R) ]\n\n for r in range(R):\n\n for c in range(C):\n\n if board[r][c] == '#': answer[r][c] = '#'\n\n if answer[r][c] is not None: continue\n\n tromino = get_tromino(board, r, c)\n\n neighbors = spread(board, tromino, False)\n\n colors_seen = set( answer[rr][cc] for rr, cc in neighbors )\n\n i = 0\n\n while digits[i] in colors_seen: i += 1\n\n for rr, cc in tromino: answer[rr][cc] = digits[i]\n\n return [ ''.join(row) for row in answer ]\n\n```\n\nExercise: Above, we have shown that 10 colors are enough. However, this algorithm would actually work with fewer than 10 colors. What is the smallest number of colors C for which the above algorithm still works? And is that number of colors worst-case optimal, or is there another algorithm that will always find a coloring with fewer than C colors?\n\n## DigitStringDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15142)\n\nThere are 2^47 ways to erase characters from a 47-character string, and we cannot afford to check all of them. Thus, we need some clever way of counting.\n\nAlmost all the ways to erase characters will usually be good. As long as we make sure that the first character we leave is not a ‘0’ and that we leave at least 10 characters, we will certainly have a number that’s big enough (as the largest valid X has only 9 digits). However, this observation is still not enough to get an algorithm that would be fast enough: there are (47 choose 9) = 1,362,649,145 ways to choose which 9 of 47 characters we should leave, and in general we would need to examine each of those, even if we could handle all the bigger numbers by some formula.\n\nAnother line of thought would be to try some dynamic programming. Imagine that we go through the input string from the left to the right, and for each character we’ll recursively try out both possibilities, one after another: either we keep it or we erase it. How can we describe our state somewhere in the middle of this recursive search? One possibility looks as follows. We need to specify:\n\n- How many input characters we already processed.\n- How many of them we kept.\n- If we kept at most nine, what is the number they form.\n\nSadly, the above is still too slow, as for a random string of digits we can eventually get very many different 9-digit numbers, so we still have way too many states.\n\nLuckily, this approach can still be saved, we just need to make one more observation. Suppose X = 456789 and you already kept three digits. The state where your current number is “123” and the state where it is “455” are exactly the same -- in either case, you need any 4 digits to be bigger than X, but no 3 digits will be enough. Similarly, “457” and “989” are equivalent in that any 3 appended digits will give you a number bigger than X. Inbetween there is a third case: “456”, in other words, the digits we kept so far form a prefix of X.\n\nThus, we can reduce our state space as follows. Let D be the number of digits of X. Then, each state can be described by the following:\n\n- a = How many input characters we already processed.\n- b = How many of them we kept.\n- c = 0/1/2, where:\n- c = 0 means that the number we kept is smaller than the number formed by the first b digits of X\n- c = 1 means that it is equal\n- c = 2 means that it is bigger (and we also use this state whenever b > D).\n\nThis leaves us with just 47*47*3 states, and for each of them we can compute the answer simply by trying out two possibilities: whether to keep or to erase the next character of the input string.\n\nIn my implementation I used a slightly different approach that is easier to code. I simply noticed that, for example, if you have X = 456789, then any prefix that is between “457” and “4566”, inclusive, is equivalent. Then, I just implemented the previous solution, but whenever my current number falls between two prefixes of X, before doing memoization I simply change it to (the shorter prefix of X) + 1. This is implemented in the function “fix” below.\n\n```\nclass DigitStringDiv1:\n\n def fix(self, value, limit):\n\n while True:\n\n if value > limit: return limit+1\n\n if value == limit: return limit\n\n limit //= 10\n\n def solve(self, where, took):\n\n if where == len(self.S): return 1 if took > self.X else 0\n\n key = (where, took)\n\n if key in self.memo: return self.memo[key]\n\n self.memo[key] = self.solve( where+1, took )\n\n if took > 0 or self.S[where] != '0':\n\n new_took = self.fix( 10*took + int( self.S[where] ), self.X )\n\n self.memo[key] += self.solve( where+1, new_took )\n\n return self.memo[key]\n\n def count(self, S, X):\n\n self.S, self.X, self.memo = S, X, {}\n\n return self.solve(0,0)\n```\n\n## BoardCoveringDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15144)\n\nThis problem is a generalization of Golomb’s famous problem: show that any square board with side length 2^k and one black cell can be tiled. That version has a short and beautiful recursive solution, and if you don’t know it, try solving that problem before this one.\n\nAn obvious necessary condition for a solution to exist is that the number of squares on the n times n board must be of the form 3k+1 for some k. In other words, n cannot be divisible by 3. It turns out that this condition is also sufficient -- all remaining boards can be tiled. Even better: all rectangles that have both dimensions at least 2 and area of the form 3k+1 can be tiled.\n\nA good strategy for problems like this one is to reduce the bigger problems to smaller ones: find a way to take any large instance and construct a partial solution (in our case, a partial tiling) in such a way that the part that remains to be solved is another valid and solvable instance. If you can do that, you can then take an arbitrarily large instance and apply the above steps repeatedly, until you get one of finitely many constant-size instances that are too small for the rule to apply.\n\nAnother good strategy: when left with finitely many cases, before you solve them manually, use symmetry to reduce their number. In our case, we can flip the board diagonally, horizontally, and/or vertically to get it into one of very few “canonical positions”.\n\nFor the first part of this solution, note that if you have to tile a large rectangle, one thing you can do is choose a side that is far from the black square, and tile the first 3 rows/columns along that side by laying down a sequence of I-shaped trominoes. This leaves you with a smaller rectangle to tile. If you repeat steps of this form, you will eventually be left with one of finitely many tiny rectangles.\n\nThe pseudocode of the resulting solution follows. (R and C denote the number of rows and columns of the current board, rb and cb denote the coordinates of the black square within that board.)\n\nwhile True:\n\n if R ```>=``` 5 and you can tile the first or the last three rows, do so\n\n if C ```>=``` 5 and you can tile the first or the last three columns, do so\n\n if you didn’t tile anything new, break\n\nlet “board” denote the part that remains to be tiled\n\nflip the board horizontally and vertically, if needed, to get the black cell into its upper left quarter\n\nflip the board diagonally if (R > C) or (R == C and rb > cb)\n\nat this moment, (R,C,rb,cb) must be one of the following:\n\n (1,1,0,0), (2,2,0,0), (4,4,0,0), (4,4,0,1), (4,4,1,1), (2,5,0,2), (5,5,2,2)\n\nfor each of those cases, construct a solution by hand\n\nflip the manually-constructed solution to undo the flips you did above\n\nonce you have the full tiling, solve the Div2 version of this task (i.e., just color the trominoes greedily, always using the smallest available color)\n\nCan you find a solution with fewer cases that need to be solved by hand? There certainly are such solutions. The main reason why I picked this one was that it’s conceptually as simple as can be, even if it may require a bit more manual work.\n\n## SimpleMathProblemDiv1\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15146)\n\nObviously, this is a problem about primes. Also obviously, 3,333,377,777 is quite a large number.\n\nAfter parsing the problem statement it’s quite obvious that the sum f(1) + … + f(X) only involves primes up to X, and one possible strategy is to consider each of those primes separately. Our hopes die in a fire as soon as a quick query to Wolfram Alpha confirms what we already estimated: there are over 159 million primes in that range and we cannot afford to generate them and consider each of them separately.\n\nOn the other hand, the square root of X is small enough (less than 60,000) and the number of primes up to sqrt(max X) is less than 6,000. This observation gives us a possible line of attack:\n\n1. Find all primes up to sqrt(X).\n2. For each of these primes, count its contribution to the result.\n3. Do something magical to find the contribution of all those larger primes.\n\nWell, steps 1 and 2 are easy, but what about step 3? The intuition why we can be hopeful that this approach can succeed is that these primes are “easier” than the ones in the general case: if you have a prime p > sqrt(X), p^2 is already too large, and therefore each n that is divisible by p only contributes p to the total. In other words, the contribution of this p to the sum of all f(n) is simply (p times (the number of n divisible by p)).\n\nThus, the sum we need is sum( p*(X div p) ) over all primes p in (sqrt(X),X]. The question remains: how can we find this sum without finding all of the primes?\n\nLet’s split these primes into smaller groups according to the value of (X div p). For each of these groups, we will compute the sum of primes it contains, and we will then multiply their sum by the corresponding value.\n\nThe value of (X div p) lies in the interval [1,p). For d > 1, the primes such that X div p = d lie in the interval [X/d,X/(d-1)). (Both endpoints are reals, not necessarily integers.)\n\nLet S(n) denote the sum of all primes that are less than or equal to n. We can compute the sum of primes in each of our intervals by computing S(n) for the sqrt(X) values of n that are of the form X/d, and taking differences.\n\nAdditionally, let T(n,x) denote the sum of all numbers between 1 and n that do not have any factor between 2 and x, inclusive. Clearly, S(n) = T(n,n-1), but a more clever way is to say S(n) = T(n,p) + S(p) - 1, where p is the largest prime <= sqrt(n). The values S(p) we need in this step can be easily precomputed, so all we need is T(n,p).\n\nA clever way to compute these values is based on the following recurrences:\n\nT(n,1) = n(n+1)/2\n\nT(n,p) = T(n,p’) - p*T(n/p,p), where p’ is the biggest prime smaller than p, or 1 if there is no such prime\n\n(For the recursive step, we need to subtract the sum of all numbers that are <=n and whose smallest prime factor is exactly p. When we divide each of these numbers by p, we get precisely the numbers that are <=n/p and whose smallest factor is p or more. Again, note that the first argument in T(n/p,p) is a real, not necessarily an integer.)\n\nIf we precompute answers with n <= sqrt(X), the remaining states are rather sparse. There are sqrt(X) possible values for the first argument: X, X/2, …, X/floor(sqrt(X)). If the first argument is n, for the second one we only need to consider primes up to sqrt(n). Summing up those, we can show that the total number of states we’ll need to evaluate is O(X^(¾) / log(X)).\n\nProblem author’s code follows.\n\n```\nlong calc(long X, long p){\n\nlong p1 = p, res = 0;\n\nwhile(true){\n\nlong p2 = p1 * p;\n\nif(p2 > X){\n\nres += (X / p - p1 / p + 1) * p1;\n\nbreak;\n\n}else{\n\nres += (p1 - p1 / p) * p1;\n\np1 = p2;\n\n}\n\n}\n\nreturn res;\n\n}\n\nlong f2(long X){\n\nif(X % 2 == 0)return X / 2 * (X+1);\n\nreturn (X+1)/2 * X;\n\n}\n\nlong calculate(long X){\n\nlong n = X;\n\nif(n == 1)return 0;\n\nint m = (int)Math.sqrt((double)n + 0.5);\n\nlong[] A = new long[m + 1];\n\nlong[] B = new long[m + 1];\n\nboolean[] fg = new boolean[m + 1];\n\nint[] primes = new int[99999];\n\nint nprime = 0;\n\nfor(int i=2; i<=m; i++){\n\nif(!fg[i])primes[nprime++] = i;\n\nfor(int j=0; j m)break;\n\nfg[x] = true;\n\nif(i%primes[j]==0)break;\n\n}\n\n}\n\nfor(int i=1; i<=m; i++){\n\nA[i] = f2(i)-1;\n\nB[i] = f2(n/i)-1;\n\n}\n\nlong res = 0;\n\nfor(int t = 0; t < nprime; t++){\n\nint p = primes[t];\n\nif(p > m)break;\n\nres += calc(n, p);\n\nlong d = A[p-1];\n\nlong p2 = (long)p * p;\n\nlong to1 = n / p2;\n\nif(to1 > m)to1 = m;\n\nint to = (int)to1;\n\nint mid = (int)(m / p);\n\nfor(int i=1; i <= mid; i++)\n\nB[i] -= (B[i*p] - d) * p;\n\nlong tmp = n/p;\n\nfor(int i=mid+1; i <= to; i++)\n\nB[i] -= (A[(int)(tmp / i)] - d) * p;\n\nfor(int i=m; i>=p2; i--)\n\nA[i] -= (A[i/p]-d) * p;\n\n}\n\nlong cur = A[m];\n\nfor(int i=m; i>=1; i--){\n\nres += (B[i] - cur) * i;\n\ncur = B[i];\n\n}\n\nreturn res;\n\n}\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"15hZ81f4IwUr58BBvJwPrf","type":"Entry","createdAt":"2019-11-28T11:58:14.181Z","updatedAt":"2020-03-31T13:36:21.559Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":7,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"misof","tcHandle":"misof","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2E7acuXQQKFsBewSg1AxMG","type":"Asset","createdAt":"2020-03-31T13:36:18.289Z","updatedAt":"2020-03-31T13:36:18.289Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":3,"revision":1,"locale":"en-US"},"fields":{"title":"misof big","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/2E7acuXQQKFsBewSg1AxMG/f8507d688787d65784dc2410d808d3f8/misof_big.jpg","details":{"size":3899,"image":{"width":126,"height":140}},"fileName":"misof_big.jpg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-741-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3DkU8osqL7BG1liDiSdtwo","type":"Entry","createdAt":"2020-04-20T12:42:12.956Z","updatedAt":"2026-03-01T18:57:22.674Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":31,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 742","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Haskell"],"creationDate":"2018-12-03T00:00:00.000Z","readTime":"15 min","content":"# Single Round Match 742 Editorials\n\nI participated on SRM 742 Div II and, inspired by my brother's editorial of SRM 739, decided to present my solutions here!\n\nDuring SRM I was solving tasks in C++ but, since I am currently learning Haskell, I will also present my solutions in Haskell.\n\n## BirthdayCandy (250)\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15213)\n\nTo figure out how many candies will Elisa get if she picks specific candy bag, we do the whole number division with (K + 1) to learn how many rounds of giving candies Elisa will do. Then, we take the rest of the candies (which is remainder from the whole division with (K + 1) and sum it up with the number of rounds and that is the total number of candies Elisa would get from that bag of candies. We do this for every bag of candies and return the biggest number.\n\n### C++\n```\n#include \nusing namespace std;\nclass BirthdayCandy {\npublic:\nint mostCandy(int K, vector candy) {\nint maxCandy = -1;\nfor (int i = 0; i < (int) candy.size(); i++) {\nconst int numCandy = candy[i] / (K + 1) + candy[i] % (K + 1);\nif (numCandy > maxCandy) maxCandy = numCandy;\n}\nreturn maxCandy;\n}\n};\n```\n\n### Haskell\n\nIt is really easy to describe this solution in Haskell, resulting in just one line of logic!\nmodule BirthdayCandy (mostCandy) where\n```\nmostCandy :: Int -> [Int] -> Int\nmostCandy k = maximum . map (\\c -> c `div` (k + 1) + c `mod` (k + 1))\n```\n\n## SixteenQueens (500)\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15227)\n\nAt first, this one seems hard, if we want to make sure that we arrange queens in an optimal way so that the biggest amount of them can fit on the board.\n\nHowever, if we look at the constraints (board size and the maximal number of queens), we can figure out that the board is so big that we can just put queens one by one in a greedy manner on it and there will always be enough space for all of them.\n\nTherefore, we go with the greedy solution where we, for each queen that we want to add, go through all the fields on the board until we find the first field that is available (not under attack by queens that are already on the board).\n\nThen we put the new queen on the board and continue with the next queen.\nTo figure out if the field is under attack we check that it is not on the same diagonal, row or column as any other queen.\n\nNice way to check if two fields are on the same diagonal is by checking if the absolute difference of their row indexes is equal to the absolute difference of their column indexes. If it is, they are on the same diagonal, otherwise, they are not.\n\n### C++\n```\n#include \n#include \nusing namespace std;\nclass SixteenQueens {\npublic:\nvector addQueens(vector row, vector col, int add) {\nvector result;\nfor (int i = 0; i < add; i++) { // For each queen that we want to add.\nbool done = false;\nfor (int r = 0; r < 50 && !done; r++) { // Let's try every field on the board. Every row.\nfor (int c = 0; c < 50 && !done; c++) { // And every column.\nbool fieldOk = true; // Is field ok to put queen on it?\n// Check if any of previous queens is compromising the field.\nfor (int j = 0; j < (int) row.size() && fieldOk; j++) {\nif (r == row[j] || c == col[j] || (abs(r - row[j]) == abs(c - col[j]))) {\nfieldOk = false; break;\n}\n}\nif (fieldOk) { // If field is ok to go, put queen on it.\nrow.push_back(r); col.push_back(c); // Add to queens on board.\nresult.push_back(r); result.push_back(c); // Add to results.\ndone = true;\n}\n}\n}\n}\nreturn result;\n}\n};\n```\n\n### Haskell\n\nThis problem can naturally be described recursively, which results in a very elegant solution in Haskell.\n\n```\nmodule SixteenQueens (addQueens) where\naddQueens :: [Int] -> [Int] -> Int -> [Int]\naddQueens row col 0 = []\naddQueens row col add = rAdd:cAdd:(addQueens (rAdd:row) (cAdd:col) (add - 1))\nwhere (rAdd, cAdd):_ = [(r, c) | r <- [0..49], c <- [0..49], not (isUnderAttack (r, c))]\nisUnderAttack (r, c) = any (\\(r', c') -> r == r' || c == c' || abs (r - r') == abs (c - c')) (zip row col)\n```\n\n## ResistorFactory (1000)\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15226)\n\nThis task I was not able to finish during the SRM - I did come up with the solution and started implementing it, but “thinking part” took me a long time and I did not have enough time left to finish it. I finished it later and confirmed in the practice room that it works correctly.\nWhile the problem is in itself simple - combine resistors to achieve wanted value - the solution is not so obvious.\n\nThe way problem is stated made me consider if there is a dynamic programming solution, however, I concluded that search space is just too big and I could not see any smart way to narrow down that search. There are just too many choices - resistor values can be real numbers, we can do series or parallel, we can combine any two resistors that we have built so far.\n\nTherefore, I decided to somehow simplify the situation.\n\n__Series doubles, parallel halves__\n\nFirst, we can observe that if we put a resistor in series with itself, we get a resistor with double the resistance, and if we put it in parallel, we get a resistor with half the resistance. This means that if we start with a resistor of resistance R, we know how to easily create resistors of resistance 2^x * R where x is an integer.\n\nSince we start with a resistor of 10^9 nano ohm (all the values from now on I will express in nano-ohms), we can create 2 * 10^9 resistor by putting it in series with itself, or we can create 0.5 * 10^9 resistor by putting it in parallel with itself. We can then repeat this process with newly created resistors to create smaller and bigger resistors.\n\n__Creating an inventory__\n\nNext, we can observe that if we have an inventory of resistors with various values, we can just put some of them in series and probably get pretty close to the target value. But, what kind of values should those be, so that we can actually do that?\n\n1. We need a resistor of small enough value that we can achieve any possible target value with high enough precision. Precision defined in the problem is 1 nano ohm.\n2. We need resistors to have big enough values so that we don't need to combine too many resistors in series since limit stated by the problem is 1000 commands, which means that we can't combine more than 1000 resistors.\n\nWe start our inventory with the only resistor we have at the beginning, resistor #0 with a resistance of 10^9 nano-ohms.\n\nCombining the observations so far, we can see that if we repeatedly create smaller and bigger resistors as described before (by doubling and halving), we will cover the space of possible target resistor values (from 0 to 10^18 nano-ohms) with values that are logarithmically (base 2) spaced.\n\nTo cover that space densely enough and to also be sure that we have small enough resistor to always be able to obtain the needed precision, we can keep halving the smallest resistor in the inventory and doubling the biggest resistor in the inventory until the smallest resistor is 2^-30 * 10^9 (~ 0.001) nano-ohms and the biggest resistor is 2^29 * 10^9 (~0.54 * 10^18) nano-ohms.\n\nNow, let's observe the commands needed to build such inventory.\nFirst, let's build resistors from 2 * 10^9 to 2^29 * 10^9, that is 29 resistors. We can do this by repeatedly putting the last resistor in inventory in series with itself, 29 times.\nThis results in following commands:\n[(0, 0, 0), (1, 1, 0), ..., (27, 27, 0), (28, 28, 0)]\n\nNext, let's build resistors from 2^(-1) * 10^9 to 2^(-30) * 10^9, that is 30 resistors. The first resistor we build by putting the resistor #0 in parallel with itself and then we repeatedly put the last resistor in inventory in parallel with itself, 29 times.\nThis expands our list of commands to a total of 59 commands:\n[(0, 0, 0), (1, 1, 0), ..., (27, 27, 0), (28, 28, 0), (0, 0, 1), (30, 30, 1), (31, 31, 1), ..., (59, 59, 1)]\n\nValues of created resistors (in ohms, not in nano-ohms!):\n[2^1, 2^2, ..., 2^28, 2^29, 2^-1, 2^-2, 2^-3, ..., 2^-30]\n\nDoes this inventory satisfy our needs from before?\n\nThe smallest resistor is smaller than required precision, so that is ok. The only question that remains is, are we sure that we can always build target resistor with less than 1000 - 59 = 941 commands by using this inventory of resistors that we created?\n\n__Building target resistor from the inventory__\n\nFirst, let's see how we can use our resistor inventory to build the target resistor.\nThe problem states that the last command in our list of commands has to be the one constructing target resistor.\n\nWith inventory just freshly built, the last command is currently the one that constructs resistor of 2^-30 ohms (~0.93 nano-ohms).\n\nIf that is not close enough to target resistor, we are going to add to it, in series, another resistor from inventory that will bring us as close as possible to target resistor (which is the biggest resistor that is smaller than the difference between target resistor value and the last resistor in inventory). We are going to repeat this process until we construct the resistor that is close enough to target resistor, and that is it!\n\nNow, to answer the question from before, if we can guarantee that we are not going to need more than 1000 commands in total.\n\nSince distance between our inventory resistors is logarithmic with base 2 it means that with each resistor we add to series while building target resistor as described above we are halving the mistake between our current best resistor and target resistor, which means that a few dozen steps (<= 60) will be always enough to build it!\nThis means we are in total never going to have more than 59 + 60 = 119 commands, which is way below the limit of 1000.\n\nThat is all! Although slightly complex, this solution performs very well in terms of speed and is reliable. I do wonder if there is a simpler solution or solution that returns the smallest number of commands but have not thought of one yet.\n\n### C++\n```\n#include \nusing namespace std;\nclass ResistorFactory {\npublic:\nvector construct(long long nanoOhms) {\nvector commands;\nvector values;\nvalues.push_back(1000000000.0); // Product 0 is 10^9 ohm.\nfor (int i = 0; i <= 28; i++) { // Products 1 to 29, each next is 2 times bigger.\ncommands.push_back(i); commands.push_back(i); commands.push_back(0);\nvalues.push_back(((double) values[values.size() - 1]) * 2);\n}\n// Product 30, which is 10^9 / 2 (product #0 / 2).\ncommands.push_back(0); commands.push_back(0); commands.push_back(1);\nvalues.push_back(values[0] / 2);\nfor (int i = 30; i <= 58; i++) { // Products 31 to 59. each is 2 times smaller.\ncommands.push_back(i); commands.push_back(i); commands.push_back(1);\nvalues.push_back(((double) values[values.size() - 1]) / 2);\n}\n// Inventory is built! Now we use our inventory to build the final resistor.\ndouble remaining = nanoOhms - values[values.size() - 1]; // Difference between what we have and target.\nwhile (remaining >= 1) {\nint bestIdx = -1; // Biggest resistor that is smaller than remaining amount.\nfor (int i = 0; i < (int) values.size(); i++) {\nif (values[i] <= remaining && (bestIdx == -1 || remaining - values[i] < remaining - values[bestIdx])) {\nbestIdx = i;\n}\n}\ncommands.push_back(values.size() - 1); commands.push_back(bestIdx); commands.push_back(0);\nvalues.push_back(values[values.size() - 1] + values[bestIdx]);\nremaining -= values[bestIdx];\n}\nreturn commands;\n}\n};\n```\n\n### Haskell (v1, more expressive)\n\nFirst Haskell version I came up with ended up pretty big, due to me writing very expressive code. This comes natural when writing Haskell because it is so easy to define functions and data types.\n```\nmodule ResistorFactory (construct) where\nimport Data.List (foldl', maximumBy)\nprecisionInNanoOhm = 1 :: Double\ndata ResistorBuild = Parallel Resistor Resistor | Series Resistor Resistor | OnePiece\ndata Resistor = Resistor { getResistorId :: Int, getValueInNanoOhm :: Double, getBuild :: ResistorBuild }\nresistorToCommand :: Resistor -> (Int, Int, Int) -- Transforms resistor into format expected by Topcoder as result.\nresistorToCommand (Resistor _ _ (Series r1 r2)) = (getResistorId r1, getResistorId r2, 0)\nresistorToCommand (Resistor _ _ (Parallel r1 r2)) = (getResistorId r1, getResistorId r2, 1)\nresistorToCommand _ = error \"Can't be transformed to command!\"\ncreateFromSeries :: Int -> Resistor -> Resistor -> Resistor\ncreateFromSeries id r1 r2 = Resistor id (getValueInNanoOhm r1 + getValueInNanoOhm r2) (Series r1 r2)\ncreateFromParallel :: Int -> Resistor -> Resistor -> Resistor\ncreateFromParallel id r1 r2 = Resistor id (v1 * v2 / (v1 + v2)) (Parallel r1 r2)\nwhere (v1, v2) = (getValueInNanoOhm r1, getValueInNanoOhm r2)\ntype Inventory = [Resistor]\nresistor0 = Resistor 0 (10^9) OnePiece -- This is the resistor we start with, 1 ohm.\ninitialInventory :: Inventory\ninitialInventory = [resistor0] -- Initial resistor.\n-: (extendInventory createFromSeries [1..29]) -- Big resistors (> 10^9 nano ohm).\n-: ((createFromParallel 30 resistor0 resistor0):) -- First small resistor.\n-: (extendInventory createFromParallel [31..59]) -- Other small resistors (< 10^9 nano ohm).\nwhere\n-- For each of given ids, it takes last resistor from inventory, creates new one with that id from it and\n-- adds it to the end of that same inventory, repeating the process.\nextendInventory create ids inv = foldl' (\\i@(r:_) id -> (create id r r):i) inv ids\na -: f = f a\nconstruct :: Integer -> [(Int, Int, Int)]\nconstruct target = transformResult $ construct' initialInventory (fromIntegral target)\nwhere transformResult = map resistorToCommand . tail . reverse\n-- Given initial inventory and value of target resistor, it will return inventory in which\n-- last resistor has that value (within defined precision).\nconstruct' :: Inventory -> Double -> Inventory\nconstruct' inv@(lastResistor:_) target = if diff < precisionInNanoOhm\nthen inv -- We are done.\nelse construct' (newResistor:inv) target\nwhere\ndiff = target - (getValueInNanoOhm lastResistor)\nclosestResistor = maximumBy (\\r1 r2 -> compare (getValueInNanoOhm r1) (getValueInNanoOhm r2))\n$ filter (\\r -> getValueInNanoOhm r <= diff) inv\nnewResistor = createFromSeries (getResistorId lastResistor + 1) lastResistor closestResistor\n```\n\n### Haskell (v2, less expressive)\n\nI also refactored it to make it shorter but less expressive and therefore much more similar to C++ version. I prefer the first, more expressive version.\n\n```\nmodule ResistorFactory (construct) where\nimport Data.List (foldl', maximumBy)\ninitialInventory :: [(Int, Int, Int, Double)]\ninitialInventory = [(undefined, undefined, undefined, 10^9)] -- Initial resistor.\n-: (extendInventory (\\id v -> (id, id, 0, v * 2)) [0..28]) -- Big resistors (> 10^9 nano ohm).\n-: ((0, 0, 1, 10^9 / 2):) -: (extendInventory (\\id v -> (id, id, 1, v / 2)) [30..58]) -- Small resistors.\nwhere extendInventory create ids inv = foldl' (\\i@((_,_,_,v):_) id -> (create id v):i) inv ids\na -: f = f a\nconstruct :: Integer -> [(Int, Int, Int)]\nconstruct target = transformResult $ construct' initialInventory (fromIntegral target)\nwhere transformResult = map (\\(id1, id2, c, v) -> (id1, id2, c)) . tail . reverse\nconstruct' :: [(Int, Int, Int, Double)] -> Double -> [(Int, Int, Int, Double)]\nconstruct' inv@(lastRes:_) target = if diff < 1 then inv else construct' (newRes:inv) target\nwhere lenInv = length inv\ndiff = target - (value lastRes)\n(bestResId, bestRes) = maximumBy (\\(_, r1) (_, r2) -> compare (value r1) (value r2))\n$ filter (\\(_, r) -> value r <= diff) $ zip [lenInv - 1, lenInv - 2 .. 0] inv\nnewRes = (lenInv - 1, bestResId, 0, value lastRes + value bestRes)\nvalue (_,_,_,v) = v\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"3nBIhGZw5ZXrZFWFXCB6u4","type":"Entry","createdAt":"2020-04-20T12:42:13.015Z","updatedAt":"2020-04-20T12:42:13.015Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Martinsos","tcHandle":"Martinsos"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-742-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"7By8AXrUBzgLzHfyf9vVQQ","type":"Entry","createdAt":"2020-04-20T12:42:13.126Z","updatedAt":"2026-03-01T18:48:17.081Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 743","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Java"],"creationDate":"2018-12-11T00:00:00.000Z","readTime":"25 min","content":"# Single Round Match 743 Editorials\n\n## PlayingWithPlanks - Div2 Easy\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14664)\n\nThe intended solution for this problem is simple -- test whether C(pieces+1, 2) is at most __plankLength__ or not. If it is bigger, return “impossible”, and otherwise return “possible”.\n\nWe now sketch why this approach is correct.\n\nObserve that if C(__pieces__+1, 2) ```>``` plankLength then we can not construct a valid solution. That is, even if all the assigned lengths are the smallest possible (the i-th piece having length i), their sum is C(__pieces__+1, 2).\n\nOn the other hand, if C(__pieces__+1, 2) ```<=``` plankLength, we can set lengths for first __pieces__-1 pieces to be from 1 through pieces-1, and the last piece to have length plankLength-C(__pieces__, 2) ```>=``` __pieces__.\n\nCode in Java:\n\n```\npublic String canItBeDone(int plankLength, int pieces) {\n\nif (pieces * (pieces + 1) / 2 <= plankLength)\n\nreturn \"possible\";\n\nreturn \"impossible\";\n\n}\n```\n\n## FriendlyRooks - Div2 Medium\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14205)\n\nThis task is a graph theory problem. Namely, consider the graph in which the vertex set consists of the rooks. Two vertices, i.e., two rooks, are connected by an edge iff for those two rooks all the three conditions are satisfied (the rooks are in the same row or in the same column, and there are no other rooks between them).\n\nIt is not hard to see that in this graph all the rooks that are in one connected component have to be of the same color. To see that, assume that two rooks in the same component have different colors and consider a shortest path between differently colored rooks. On this shortest path there exists an edge whose endpoints have different colors, which violates friendly coloring.\n\nSimilarly, if two rooks are not in the same component, then they can be colored by different colors.\n\nNow this tasks comes down to building such graph. The final output is the number of connected components that this graph contains.\n\nTo count the number of connected components one can simply run DFS or BFS and that would be more than sufficient to solve this problem in time. \n\nNote: Observe that out of those three conditions, the third condition (the one that says that there should be no rooks between two rooks attacking each other) also can be omitted and this task would not get changed. So, for the sake of easier implementation we can as well just ignore this constraint.\n\nCode in Java:\n```\n\nprivate int[][] vec = undefined;\n\nprivate int n, m;\n\nprivate boolean[][] done;\n\nprivate boolean possible(int i, int j) {\n\nreturn i > -1 && j > -1 && i < n && j < m;\n\n}\n\nprivate String[] board;\n\nprivate void mark(int i, int j) {\n\ndone[i][j] = true;\n\nfor (int k = 0; k < 4; k++) {\n\nint ni = i;\n\nint nj = j;\n\nfor (int t = 0; t < Math.max(n, m); t++) {\n\nni += vec[k][0];\n\nnj += vec[k][1];\n\nif (possible(ni, nj) && board[ni].charAt(nj) == 'R' && !done[ni][nj]) {\n\nmark(ni, nj);\n\nBreak;\n\n}\n\n}\n\n}\n\n}\n\npublic int getMinFriendlyColoring(String[] board) {\n\nthis.board = board;\n\nn = board.length;\n\nm = board[0].length();\n\ndone = new boolean[n][m];\n\nfor (int i = 0; i < n; i++)\n\nArrays.fill(done[i], false);\n\nint ret = 0;\n\nfor (int i = 0; i < n; i++)\n\nfor (int j = 0; j < m; j++)\n\nif (board[i].charAt(j) == 'R' && !done[i][j]) {\n\nret++;\n\nmark(i, j);\n\n}\n\nreturn ret;\n\n}\n```\n\n## MaximizingGCD - Div2 Hard and Div1 Easy\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/15211)\n\nWe reduce this task to one that for a given g decides whether there is a pairing C such that each number of C is divisible by g. This question can be solved as follows.\n\n__Testing whether g divides each number of some pairing:__\n\nFor a given g, compute A[i]%g for each i. Then, the number of i's such that A[i]%g == 0 has to be even. If g is even, then the number of i's such that A[i]%g == g/2 has to be even as well. For all the other modulos of g, the number of i's and the number of j's such that A[i]%g == k and A[j]%g == g-k has to be the same.\n\nSo, we now know how to decide whether there exists a pairing that certifies that the output to the problem is at least g. But how to find all the relevant values of g for which we should run the above procedure? One choice is to try all the values 1 through 2 * 10^9 in place of g, but that would be too slow. Next we discuss how to select relevant but small number of candidates for g.\n\n__A small number of relevant g’s:__\n\nObserve that A[0] has to be paired with some element of A. So, the final output has to divide A[0]+A[i] for some i. In our solution, for each of the divisors d of A[0]+A[i] we ask whether there exists a pairing as described above (for g = d). Luckly, the number of positive divisors of an integer X is at most 2 * sqrt(X).\n\nIn our case, that is at most 2 * sqrt(2 * 10^9) many divisors of A[0]+A[i], for any fixed i. Since there are at most 30 such candidates A[0]+A[i], the total number of divisors of interest is at most 30 * 2 * sqrt(2 * 10^9). For each of those divisors we invoke the procedure described above. The largest of those candidates for which the procedure above reports that there exists the corresponding pairing is the output of the solution.\n\nCode in Java:\n\n```\nprivate ArrayList candidates;\n\npublic int maximumGCDPairing(int[] A) {\n\nint n = A.length;\n\ncandidates = new ArrayList < Integer > ();\n\nfor (int i = 1; i < n; i++) {\n\nint val = A[0] + A[i];\n\nint d = 1;\n\nwhile (d * d <= val) {\n\nif (val % d == 0) {\n\ncandidates.add(d);\n\ncandidates.add(val / d);\n\n}\n\nd++;\n\n}\n\n}\n\nint ret = -1;\n\nfor (Integer candidate: candidates) {\n\nif (candidate < ret) Continue; ArrayList < Integer > rems = new ArrayList < Integer > ();\n\nint cntZero = 0, cntHalf = 0;\n\nfor (int val: A) {\n\nif (val % candidate == 0)\n\ncntZero++;\n\nelse if (2 * (val % candidate) == candidate)\n\ncntHalf++;\n\nelse\n\nrems.add(val % candidate);\n\n}\n\nif (cntZero % 2 == 0 && cntHalf % 2 == 0) {\n\n// at this points, it holds rems.size() % 2 == 0\n\nCollections.sort(rems);\n\nboolean OK = true;\n\nfor (int i = 0; i < rems.size() / 2; i++)\n\nif (rems.get(i) + rems.get(rems.size() - i - 1) != candidate) {\n\nOK = false;\n\nbreak;\n\n}\n\nif (OK)\n\nret = candidate;\n\n}\n\n}\n\nreturn ret;\n\n}\n```\n\n## ExpectedSum - Div1 Medium\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15233)\n\nWe solve this problem by using dynamic programming. We define dp state by the triples (idx, B, L) with the following meaning\n\ndp[idx][B][L] = the solution to the problem where:\n\n1. The signs for indices 0 … idx-1 are already chosen (i.e., they are deterministic). Let F[i] be the value of the i-th index. Note that F[i] = sequence[i] or F[i] = -sequence[i].\n2. The largest sum of a contiguous subsequence of F[0 … idx-1] is B.\n3. The largest sum of a contiguous subsequence of F[0 … idx-1] that contain F[idx-1] is L.\n\nThe output to this problem is dp[0][0][0].\n\nLet n be the length of sequence. Then, as the boundary condition, we have\n\ndp[n][B][L] = B, for any L\n\nIt is also not hard to define the transitions from one to another state. Namely, from state (idx, B, L) there are two possible transitions.\n\n1. Either we set F[idx] = sequence[idx], which happens with probability 1-probMinus[idx]/100. Then we define L1 = L + sequence[idx] and transition to (idx + 1, max(B, L1), L1).\n2. Or, we set F[idx] = -sequence[idx], which happens with probability probMinus[idx]/100. Then we define L2 = L - sequence[idx] and transition to (idx + 1, B, max(L2, 0)).\n\nFinally, we have\n\ndp[idx][B][L] = (1-probMinus[idx]/100) * dp[idx + 1][max(B, L1)][L1] + probMinus[idx]/100 * dp[idx + 1][B][max(L2, 0)]\n\nNote that since each element ranges from 0 to 50 and it never pays off to have subarrays of negative value, there are at most 2501 possibilities for the second and the third dimension of dp. sequence is of length at most 50, so there are at most 50 possibilities for first dimension. Furthermore, from each state we make only two transitions. So, the overall running time of the solution above is 2 * 50 * 2501 * 2501, which runs in time. However, defining the full dp as described above would require too much memory.\n\nTo reduce the memory, we use a standard trick. Instead of storing all the 50 coordinates for the first dimension of dp at each step of the algorithm, we store only two consecutive ones. This is possible as to feel dp[idx] we only need information from dp[idx + 1]. This would be sufficient to cut the space by factor of 25 which is good enough to store this compressed dp table in memory.\n\n__Alternative explanation (courtesy of misof):__\n\nAnother point of view is as follows. We can read the input from left to right and run Kadane's algorithm in parallel on all possible sequences. After each step, the dp values simply represent the probabilities with which each state of the algorithm was reached. Here, state is the pair\n\n(best solution so far, best solution that ends at the end of what we processed).\n\nCode in C++:\n\n```\npublic double solve(int[] sequence, int[] probMinus) {\n\ndouble[][][] pp = new double[2][2501][2501];\n\nint N = sequence.length;\n\nint S = 0;\n\nfor (int n = 0; n < N; ++n) S += sequence[n];\n\nfor (int a = 0; a <= S; ++a)\n\nfor (int b = 0; b <= S; ++b)\n\npp[0][a][b] = 0;\n\npp[0][0][0] = 1;\n\nfor (int n = 0; n < N; ++n) {\n\nint old = n % 2, nju = 1 - old;\n\nfor (int r = 0; r <= S; ++r)\n\nfor (int s = 0; s <= S; ++s)\n\npp[nju][r][s] = 0;\n\nfor (int r = 0; r <= S; ++r)\n\nfor (int s = 0; s <= S; ++s)\n\nif (pp[old][r][s] > 0) {\n\ndouble pM = probMinus[n] / 100.;\n\nint nr1 = r + sequence[n];\n\nint ns1 = Math.max(s, nr1);\n\npp[nju][nr1][ns1] += (1 - pM) * pp[old][r][s];\n\nint nr2 = Math.max(0, r - sequence[n]);\n\nint ns2 = Math.max(s, nr2);\n\npp[nju][nr2][ns2] += pM * pp[old][r][s];\n\n }\n\n}\n\ndouble answer = 0.;\n\nfor (int r = 0; r <= S; ++r)\n\nfor (int s = 0; s <= S; ++s)\n\nanswer += s * pp[N % 2][r][s];\n\nreturn answer;\n\n}\n```\n\n## PermuteTheArray - Div1 Hard\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14835)\n\nThis is a mix of graph theory and dynamic programming. We split the explanation in two parts. First, we describe how to test whether there exists any permutation satisfying the constraints. Then we show how to use this procedure to construct the lexicographically smallest one.\n\n__Verifying whether there exists any permutation:__\n\nMake a graph on n vertices, vertex i corresponding to the i-th index of the output. Two vertices u and v are connected iff there exists i such that x[i]==u and y[i]==v. If d[i]==1, then color the edge {u, v} in red and otherwise color {u, v} in blue.\n\nNow, for every component, we start from an arbitrary vertex and assign label 0 to it. Then we run DFS to assign labels to the other vertices as well. If two vertices are connected by the blue edge, then they should have the same labels; otherwise, one vertex should have label 0 and the other one label 1. This also implies that the same label within the same component denotes vertices of the same parity. If at any point we discover an edge that does not follow these rules, we conclude that there is no such array P.\n\nOnce we have all the 0-1 labels, for every component we count the number of labels being 0 and the number of labels being 1. For component comp, let those counts be cnt0[comp] and cnt1[comp]. Then, to each comp we should either assign cnt0[comp] even and cnt1[comp] odd numbers of val; or the other way around, i.e., we should assign cnt0[comp] odd and cnt1[comp] even numbers of val. Moreover, we should make these assignments for all the components simultaneously, and each element of val should be assigned to exactly one component. If this is not possible to achieve, then there is no required P.\n\nLet E be the number of even and O be the number of odd numbers of val. We perform a dynamic programming to check whether there is a way to assign E and O across the components as described. This is a standard DP problem that can be implemented to run in O(E * number_of_components) time.\n\nWe now describe how to reconstruct the lexicographically smallest P.\n\n__Reconstruction of lexicographically smallest P:__\n\nWe begin by explaining how to reconstruct P[0]. Let comp be the component containing vertex 0. Without loss of generality, assume that vertex 0 is labeled by 0 in comp. Let S_even be the smallest even and S_odd be the smallest odd number of val. (If S_even or S_odd does not exist, set its value to infinity.) Assume that S_even < S_odd. Then, we check whether there is a permutation P such that P[0]=S_even. To check that, we test whether we can assign cnt0 and cnt1 of the components other than comp so that the total number of even values and the total number of odd values of val in this assignments is E-cnt0[comp] and O-cnt1[comp], respectively. Here we are subtracting cnt0[comp] from E (and also cnt1[comp] from O) as we are assuming that all the vertices of comp having the same parity as vertex 0 can be assigned to have even values of val.\n\nIf there does not exist such assignment, then we set P[0]=S_odd. Note that to verify whether such assignment exists we can use the same method as we used in the first part.\n\nWhen we set the value of P[0] (that is S_even or S_odd), then we mark which vertices in comp should be set to even values and which to odd values. Notice that this is uniquely determined once we decide the parity of vertex 0. Note: at this point we only mark the parity of the remaining vertices in comp, but not assign any values to them yet.\n\nThe analogous approach is applied if S_odd ```<``` S_even.\n\nThe rest of the reconstruction of P is obtained in a similar way. Namely, assume that so far we have reconstructed P[0], …, P[idx - 1], and next we want to reconstruct P[idx]. If the parity of vertex idx was already decided, then we let P[idx] be the smallest unused value of val which has the same parity as vertex idx.\n\nIf the parity of vertex idx has not been decided yet, then we apply the same procedure over idx as we applied over vertex 0 above. We only have to take into account that some of the components has been processed already.","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"AyICjsAGXwAhfNqR9a8kM","type":"Entry","createdAt":"2020-03-30T23:06:14.883Z","updatedAt":"2020-03-30T23:06:14.883Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"boba5551","tcHandle":"boba5551"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-743-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2NLGdCc3RDpIGCXsPCgmpd","type":"Entry","createdAt":"2020-04-20T12:42:14.467Z","updatedAt":"2026-03-01T18:18:17.287Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":61,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 744 Detailed","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Haskell"],"creationDate":"2018-12-20T00:00:00.000Z","readTime":"15 min","content":"# Single Round Match 744 Detailed Editorial\n\nSRM 744 was held on December 14th, 2018. The original editorial can be found here. I am currently learning Haskell so I decided to solve all tasks in it as well and then compare to my original C++ solutions.\n\n## ThreePartSplit - Div 2 Easy\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15235)\n\nShort problem statement: We are given a half open interval [a, d) which contains n = d - a elements. We need to divide it into three parts such each of them has at least n div 3 elements. We need to return the “middle” interval as [b, c) (so half open again).\n\nSolution: A simple and quick task that can be solved analytically, we just need to be careful not to mess up +-1 indices. There also multiple possible solutions, but maybe the most straightforward one (at least for me) was to assign n div 3 elements to the first two parts and then whatever is left to the third part.\n\nE.g. if we were given [0, 8) as a starting interval, that means we have numbers 0, 1, 2, 3, 4, 5, 6, 7. If we divided them as described above, we’d end up with intervals\n[0, 1], [2, 3], [4, 5, 6, 7] where we “crammed” all the extra stuff into the last interval.\nThere are also other valid solutions, e.g. we could’ve put 3 elements in each interval. So if you are using some editor plugin which compares against the example test cases (like Vimcoder) don’t worry if it reports some of your solutions as wrong.\n\n### C++\n```\nclass ThreePartSplit\n{\npublic:\nvector split(int a, int d) {\nint minIntervalSize = (d - a) / 3;\nreturn {a + minIntervalSize, a + 2 * minIntervalSize};\n}\n};\n```\n\nIt was really cool for me to learn here how we can construct and return vector in a single line, very clean and readable.\n\n### Haskell\n```\nthreePartSplit :: Int -> Int -> (Int, Int)\nthreePartSplit a d = (a + minIntervalSize, a + 2 * minIntervalSize)\nwhere minIntervalSize = (d - a) `div` 3\n```\n\n### Comparison\n\n| Language | Lines | 100 runs |\n| ---------- | ---------- | ---------- |\n| C++ | 8 | TBD |\n| Haskell | 3 | TBD |\n\nAlthough Haskell solutions has a bit less lines than C++ one (mostly due to C++ class plumbing), I would say expresiveness-wise solutions are the same. Since it is O(1) analytical solution, we don’t need any looping or mapping or data structures, and with this concise way of creating a vector C++ solution is also very nice to read.\n\n## MagicNumbersAgain - Div 2 Medium\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15212)\n\nShort problem statement: Number is magic if it is a perfect square and if its digits alternate in a fashion of greater, smaller, greater, smaller, … (e.g. 1 3 2 17 4 2 3). Given [A, B] interval, find out how many magic numbers it contains.\n\nSolution: The naive solution would be to check for each number between A and B whether it is a magic number or not. However, due to the constraints (interval can have up to 10\n10 elements), we can see it would not be fast enough in all the possible cases.\nBut if we could be a bit smarter and somehow first find all the perfect squares in [A, B] and then only examine them instead of every number in the interval, would that be more performant? Sure it would, and since we will need to examine at most 105 squares (since 105 hits the upper range bound when squared), we can be sure it is going to be fast enough.\nFinding squares is also not a problem, we can just keep iterating over the roots and generate them until we go over the upper range bound.\n\nC++\n```\nclass MagicNumbersAgain\n{\npublic:\nbool isMagic(long long num) {\n// Obtain digits of a number.\nvector digits;\nwhile (num > 0) {\ndigits.push_back(num % 10);\nnum /= 10;\n}\nreverse(digits.begin(), digits.end());\n// Perform the check on the digits.\nfor (int i = 1; i < digits.size(); i++) {\nif (i % 2 == 1) {\nif (digits[i] <= digits[i - 1]) return false;\n} else {\nif (digits[i] >= digits[i - 1]) return false;\n}\n}\nreturn true;\n}\nint count(long long A, long long B) {\n// Find all squares in [1, B].\nvector allSquares;\nfor (long long root = 1; root * root <= B; root++) {\nallSquares.push_back(root * root);\n}\n// Check for every square if in [A, B] and magic.\nint magicCount = 0;\nfor (int i = 0; i < allSquares.size(); i++) {\nlong long square = allSquares[i];\nif (square >= A && square <= B && isMagic(square)) magicCount++;\n}\nreturn magicCount;\n}\n};\n```\n\nA cool trick I learnt here is to generate all the squares from 1 up to B (or even up to the upper limit) and then later just check if it is in the required range. This frees us of doing the work of figuring out what is the first square in the range. Theoretically speaking it is not optimal since we are doing extra work, but here we can afford it and it keeps the code cleaner and less error-prone.\n\nUnfortunately I haven’t used this trick during the competition and made a mistake in just a situation described above (finding first square >= A) and my solution failed. So it is a good lesson for the future.\n\n### Haskell\n```\ncount :: Int -> Int -> Int\ncount a b = length $ filter isMagic $ squares a b\nsquares a b = takeWhile (<=b) $ dropWhile ( [Int]\ndigits 0 = []\ndigits num = digits (num `div` 10) ++ [num `mod` 10]\nisMagic :: Int -> Bool\nisMagic num = and $ map check triplets\nwhere\ndigs = digits num\n-- Produces (digit, prevDigit, index) triplets.\ntriplets = zip3 (drop 1 digs) digs [1..]\n-- Checks whether greater, smaller progression holds.\ncheck (dig, prevDig, idx)\n| idx `mod` 2 == 1 = dig > prevDig\n| otherwise = dig < prevDig\n```\n\n### Comparison\n| Language | Lines | 100 runs |\n| ---------- | ---------- | ---------- |\n| C++ | 40 | TBD |\n| Haskell | 19 | TBD |\n\nI really enjoyed writing this Haskell solution - I love how concise is the count function and how cleanly it breaks the problem into the subproblems that can be addressed (and tested) separately. I especially like squares function - how it starts with an infinite list and then we just “trim” it from the both sides until we get the desired result. This way of thinking makes it much easier for me to reason and thus much harder to introduce “off-1” type of bugs.\n\nWhat I find as most different compared to C++ solution is the situation where we have to check the digits, and compare each digit with the previous digit. Since we don’t do looping as in C++ we have to in advance construct all the “checks” with all the information needed.\n\n## ModularQuadrant - Div 2 Hard\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15236)\n\nShort problem statement: We are given an infinite, zero-indexed square grid. Each cell contains\nmax(row, column) mod 3 value. Given a rectangle in that grid, return the sum of its cells.\nSolution: The naive solution would be to go over all the cells in the given rectangle, calculate the values and sum it all together. However, since both width and height of the rectangle can be up to 109, it would be way to slow (we’d need to traverse over 1018 cells in the worst case).\nSo we need to be smarter and somehow use the properties of this grid to our advantage. Let’s examine the portion of the grid of size 10 x 10:\n\n![SRM 744 1](//images.ctfassets.net/piwi0eufbb2g/76BBGSIjjbKVLfqsf21f0Y/99ea7a7d1cfe10c18dae1c6e0771efc4/SRM_744_1.webp)\n\nI emphasized the diagonal and the red box is an example of rectangle for which we want to calculate the sum of its cells.\nWe can notice several things here:\n\n- 0 1 2 pattern repeating itself due to mod 3\n- The grid is symmetrical in respect to the diagonal (i-th row == i-th column)\n\nMy first approach was to calculate sum of each row separately and then sum that. I could calculate the sum of row in O(1) (observe the patten in a row - number is repeated until the diagonal and then starts cycling), but we still have 109 rows so that was too slow (one test case that took ~6s kept failing).\n\nSo we need to be even smarter than that - if calculating a row in O(1) is possible, is there also some kind of a rectangle whose sum we could calculate in O(1)?\nIf we could calculate sum of any rectangle that has upper left corner in 0, 0 fast enough, that would be great, because then we use that to calculate sum of any rectangle in the following way:\n\n```\ncalcRectSum(r1, r2, c1, c2) = calcRect00Sum(r2, c2) - calcRect00Sum(r2, c1 - 1) - calcRect00Sum(r1 - 1, c2) + calcRect00Sum(r1 - 1, c1 - 1)\n```\n\n![SRM 744 2](//images.ctfassets.net/piwi0eufbb2g/1U5GGGZZdAQAXUiNFpfFvy/a16885d32d2a09cb908b76ac2c9354c9/SRM_744_2.webp)\n\nThis image should also illustrate what is going on in the formula above (I apologize for the colored mess). If we want to calculate sum of the red box (in the first image) we start with a big purple rectangle and then from it substract the green and blue one. We can see the only thing that is left is what was original a red rectangle. Also, as blue and green rectangles intersect we’ve subtracted that part twice, so we have to add it once to fix that.\n\nThat’s it, we’ve managed to express the area of any rectangle with only the rectangles that start in the 0, 0, upper left corner. So now we only have to find out how to efficiently calculate sum of such a rectangle (calcRect00Sum method from above).\n\nIf we look at such a rectangle, we can divide it into two parts - square starting at (0, 0) (green) and the rest of it (orange).\n\n![SRM 744 3](//images.ctfassets.net/piwi0eufbb2g/4bbD5wGl6P1P48L7aglJd5/f4771a7132ead914fe98c51605dcfe7a/SRM_744_3.webp)\n\nCalculating a square sum - we can see that numbers are progressing in amount as odd numbers,\n1, 3, 5, 7, 9, ... and sum like that we can calculate in O(1) so we can use that. Let’s take a look at a bit bigger example of a square starting at (0, 0):\n\n![SRM 744 4](//images.ctfassets.net/piwi0eufbb2g/2b3MSZeqmAt9XSc1oh9gU3/34c5920e61e682c46eadfa07bcbdd6ad/SRM_744_4.webp)\n\nHere we can see that the square consists of “L-shaped” layers (colored in the image) that progress in the amount of cells as odd numbers (1, 3, 5, 7, ...), which is shown by numbers above the columns in the image.\n\nWe can also see that for a particular value (0, 1, 2) that the number of cells in the layer progresses by 6 (e.g. first we have 3 1s, than 9, than 15, …) - because of this period of 3, we have to “skip” two other numbers before coming to the next occurrence of the one that is observed.\nSo the sum of the square in the image above can be calculated as:\n0 * (1 + 7 + 13) + 1 * (3 + 9) + 2 * (5 + 11) = 44\n\nWe can generalize that to multiplying each value (0, 1, 2) with a sum of series that starts at a particular number, has a step of 6 and has number of elements that is equal to the number of “layers” this value has in the square.\n\nIf we can calculate the sum of this series in O(1) (and we can, check the seriesSum method in the code below), that means this whole calculation is done in O(1), which is exactly what we were aiming for.\n\nCalculating the rest - we see it has a repeating pattern in a row so we can use that to calculate the sum.\n\n### C++\n```\nclass ModularQuadrant\n{\npublic:\nlong long seriesSum(int start, int step, int length) {\nint end = start + (length - 1) * step;\nlong long sum = (long long)(start + end) * (length / 2);\nif (length % 2 == 1) sum += (start + end) / 2;\nreturn sum;\n}\nlong long calcSquare00Sum(int a) {\n// Number occurrences of 1.\nlong long onesOcc = a / 3 + (a % 3 == 2 ? 1 : 0);\n// Number occurrences of 2.\nlong long twosOcc = a / 3;\nlong long onesSum = seriesSum(3, 6, onesOcc);\nlong long twosSum = 2 * seriesSum(5, 6, twosOcc);\nreturn onesSum + twosSum;\n}\nlong long calcRectRightOfDiagonalSum(int startCol, int length, int height) {\nlong long rowSum = (length / 3) * (long long)3;\n// Add remainder part.\nint currVal = startCol % 3;\nfor (int i = 0; i < (length % 3); i++) {\nrowSum += currVal;\ncurrVal = (currVal + 1) % 3;\n}\nreturn rowSum * height;\n}\nlong long calcRect00Sum(int r, int c) {\n// The grid is symmetrical so it is the same.\nif (r > c) return calcRect00Sum(c, r);\nreturn calcSquare00Sum(r + 1) + calcRectRightOfDiagonalSum(r + 1, c - r, r + 1);\n}\nlong long sum(int r1, int r2, int c1, int c2)\n{\nreturn calcRect00Sum(r2, c2) - calcRect00Sum(r2, c1 - 1) - calcRect00Sum(r1 - 1, c2)\n+ calcRect00Sum(r1 - 1, c1 - 1);\n}\n};\n```\n\n### Haskell\n```\nseriesSum :: Int -> Int -> Int -> Int\nseriesSum start step length = (start + end) * (length `div` 2) + middleIfOdd\nwhere\nend = start + (length - 1) * step\n-- If there is odd number of elements, we have to add a middle element.\nmiddleIfOdd = if length `mod` 2 == 1 then (start + end) `div` 2 else 0\ncalcSquare00Sum :: Int -> Int\ncalcSquare00Sum a = (seriesSum 3 6 onesOcc) + 2 * (seriesSum 5 6 twosOcc)\nwhere\nonesOcc = a `div` 3 + if a `mod` 3 == 2 then 1 else 0\ntwosOcc = a `div` 3\ncalcRectRightOfDiagonalSum startCol length height = rowSum * height\nwhere\nrowSum = (length `div` 3) * 3 + remains\nstartValue = startCol `mod` 3\nremains = sum $ map (\\r -> (startValue + (r-1)) `mod` 3)[1..(length `mod` 3)]\ncalcRect00Sum :: Int -> Int -> Int\ncalcRect00Sum r c\n| r > c = calcRect00Sum c r\n| otherwise = calcSquare00Sum (r + 1) + calcRectRightOfDiagonalSum (r + 1) (c - r) (r + 1)\nrectSum :: Int -> Int -> Int -> Int -> Int\nrectSum r1 r2 c1 c2 = totalRect - leftRect - topRect + intersectRect\nwhere\ntotalRect = calcRect00Sum r2 c2\nleftRect = calcRect00Sum r2 (c1 - 1)\ntopRect = calcRect00Sum (r1 - 1) c2\nintersectRect = calcRect00Sum (r1 -1) (c1 - 1)\n```\n\n### Comparison\n| Language | Lines | 100 runs |\n| ---------- | ---------- | ---------- |\n| C++ | 52 | TBD |\n| Haskell | 31 | TBD |\n\nImplementing Haskell solution was pretty straightforward to implement from the C++ solution, we already divided the problem nicely into functions so we could just implement them in Haskell.\nThe Haskell solution is naturally shorter due to more dense syntax, but the logic stayed pretty much the same. The final function in Haskell solution, rectSum, I had to rename because\nsum is a method that comes in Haskell’s standard library.","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4cOs5oeBGycngtasBNTaoh","type":"Entry","createdAt":"2020-04-20T12:42:13.520Z","updatedAt":"2020-04-20T12:42:13.520Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Matija","tcHandle":"Matija"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-744-detailed-editorial/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"5HV8m8eFK99EYISudKu4g1","type":"Entry","createdAt":"2020-04-20T12:42:13.119Z","updatedAt":"2026-02-25T14:48:45.813Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":57,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 744","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Java"],"creationDate":"2018-12-14T00:00:00.000Z","readTime":"25 min","content":"# Single Round Match 744 Editorials\n\nThe match was held on December 14th. The problem set and editorials were prepared by __[boba5551](https://profiles.topcoder.com/boba5551)__.\n\n## Div2 Easy - ThreePartSplit\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15235)\n\nDefine k = (d-a) div 3. We set b = a + k and c = a + 2*k. From the construction of b and c, we have that [a,b) and [b,c) have length k each. Now, the only part left is to verify that interval [c,d) has length at least k. If it wouldn’t be the case, then the sum of lengths of [a, b), [b, c) and [c, d) would be less than 3 * k. But this is a contradiction with the fact that d-a ```>=``` 3k.\n\n```\npublic int[] split(int a, int d) {\nint minLength = (d - a) / 3;\nreturn new int[] {\na + minLength, a + 2 * minLength\n};\n}\n```\n\n## Div2 Medium - MagicNumbersAgain\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15212)\n\nWe split the explanation in two parts: we explain how to verify the second condition, and then we discuss how to implement the first condition efficiently.\n\n__The second condition of being magic number:__\n\nWe assume that v is a square of an integer, and now we want to check whether it is magic or not. We can achieve that by the following simple procedure, that directly implements the statement of the condition:\n\n```\nprivate boolean isMagic(long v) {\nArrayList < Long > digs = new ArrayList < Long > ();\nwhile (v > 0) {\ndigs.add(v % 10);\nv /= 10;\n}\nboolean OK = true;\nboolean odd = true;\nfor (int i = digs.size() - 1; i > 0; i--) {\nif (odd && digs.get(i) >= digs.get(i - 1))\nOK = false;\nif (!odd && digs.get(i) <= digs.get(i - 1))\nOK = false;\nodd ^= true;\n}\nreturn OK;\n}\n```\n\nImplementing the first condition efficiently for all the numbers in [A,B]:\n\nOur next goal is to run the above procedure isMagic on all the squares between __A__ and __B__. Since __A__ and __B__ can be as big as 10^10, it would be too slow to test each of the number from that interval whether it is a square or not. However, if for each Y that “makes sense” we test whether Y^2 is between __A__ and __B__, then we obtain significantly more efficient solution. Namely, if v is between __A__ and __B__ and v=Y*Y, then Y is at most 10^5. So, we iterate over all such values of Y, and whenever Y*Y is between __A__ and __B__ we invoke the procedure above. The code in Java follows:\n\n```\npublic int count(long A, long B) {\nint ret = 0;\nfor (long v = 1; v * v <= B; v++) if (v * v >= A && isMagic(v * v))\nret++;\nreturn ret;\n}\n```\n\n## Div2 Hard and Div1 Easy - ModularQuadrant\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15236)\n\nLet cnt(r,c) be a procedure that calculates the sum of rectangle [0,r] x [0,c]. Then, the final output is cnt(__r2__+1,__c2__+1) - cnt(__r1__,__c2__+1) - cnt(__r2__+1,__c1__) + cnt(__r1__,__c1__)\n\nCalculating the sum of rectangle [0,r] x [0,c]:\n\nWithout loss of generality, assume that r ```<``` c (as the grid is symmetric with respect to r=c). Next, we divide the rectangle [0, r] x [0, c] into two parts: square in the corner r x r and vertical bars to the right of this square.\n\nTo handle the square, we observe that they have very regular form. This is how the first 6x6 part of infinite grid looks like:\n\n2 2 2 2 2 2\n\n1 1 1 1 1 2\n\n0 0 0 0 1 2\n\n2 2 2 0 1 2\n\n1 1 2 0 1 2\n\n0 1 2 0 1 2\n\nOn the other hand, each bar to the right of the square consists of the same number. And those numbers are a subset of the infinite sequences 0, 1, 2 (repeat).\n\nSo, we separately handle the square and separately handle the bars. Formulas for each of those cases can be derived relatively easily. One such implementation is provided below.\n\nCode in C++ (courtesy of [majk](https://profiles.topcoder.com/majk)):\n\n```\nll cnt(int r, int c) {\nif (r > c) swap(r, c);\nll x = r - r % 3;\nll y = c - x;\ny -= y % 3;\nreturn 4 * x / 3 + x * x + (c % 3 == 2) * r + y * r + (x + 1) * (r % 3 == 2);\n}\nll sum(int r1, int r2, int c1, int c2) {\nreturn cnt(r2 + 1, c2 + 1) - cnt(r1, c2 + 1) - cnt(r2 + 1, c1) + cnt(r1, c1);\n}\n\n```\n\n## Div1 Medium - UniformingMatrix\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15210)\n\nThe main point here is to observe that flipping rows and columns is almost independent. Namely, consider an operation applied on __M__(i, j). The problem statement says that we flip the i-th row by not changing M(i, j), and then we flip the j-th column by not changing __M__(i, j). But exactly the same outcome would be achieved by flipping the entire row i (including __M__(i, j)), and then flipping the entire column j. This observations allows us to perform row and column flips almost separately.\n\nThe second observation that we make is that applying the entire-row flipping operation on a row for even number of times does not change that row. Also, flipping odd many times the entire row results in the same state of the row as by applying the operation only once. The same holds for entire-column operations. Hence, what matters is the parity of the number of times an operations is applied on a row/column.\n\nFinally, observe that the order in which the entire-row and entire-column operations are performed does not matter.\n\nSo, we apply entire-row operations first. Consider separately the cases in which the first row is flipped zero times (i.e., an even number of times) and flipped once (i.e., an odd number of times). After flipping the entire first row for b many times (where b equals 0 or 1), and before applying entire-column operations, perform entire-row operations on each of the other rows so that they are the same as the first row. If it is not possible to achieve, than our choice of flipping the first row b many times does not lead to all-ones matrix.\n\nOnce all the rows are the same, we apply the column operations. Applying a column operation is now trivial -- the j-column should be entirely flipped iff M(0, j) equals ‘0’.\n\nAt the end, we check whether the parity of the applied entire-row and entire-column operations is the same. If it is the same, the output is “possible”, and otherwise our choice of b does not lead to all-ones matrix.\n\nIf no choice of b leads to all-ones matrix, output “impossible”.\n\nCode in Java:\n\n```\nprivate String[] M;\nprivate int n, m;\nprivate void flipRow(int i) {\nchar[] newRow = new char[m];\nfor (int j = 0; j < m; j++)\nif (M[i].charAt(j) == '0')\nnewRow[j] = '1';\nelse\nnewRow[j] = '0';\nM[i] = new String(newRow);\n}\npublic String isPossible(String[] MM) {\nM = MM;\nn = M.length;\nm = M[0].length();\nString[] origM = new String[n];\nfor (int i = 0; i < n; i++)\norigM[i] = M[i];\nfor (int changes = 0; changes < 2; changes++) {\nint cntRow = changes;\nfor (int i = 1; i < n; i++) {\nif (M[0].charAt(0) == M[i].charAt(0))\ncontinue;\ncntRow++;\nflipRow(i);\n}\nint cntCol = 0;\nboolean OK = true;\nfor (int j = 0; j < m; j++) {\nif (M[0].charAt(j) == '0')\ncntCol++;\nfor (int i = 1; i < n; i++)\nif (M[0].charAt(j) != M[i].charAt(j))\nOK = false;\n}\ncntRow %= 2;\ncntCol %= 2;\nif (OK && cntRow == cntCol)\nreturn \"possible\";\nfor (int i = 0; i < n; i++)\nM[i] = origM[i];\nflipRow(0);\n}\nreturn \"impossible\";\n}\n```\n\n## Div1 Hard - CoverTreePaths\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14587)\n\nThere are two natural approaches for this problem -- satisfy demands in top-down fashion (i.e., starting from the root and moving towards the leaves), and satisfy demands in bottom-up fashion (i.e., starting from the leaves and moving towards the root). The official solution takes the bottom-up approach, that we describe next.\n\nInitially, we set v[i] = 0 for each vertex i, and update v in n steps. After the k-th step we maintain the following invariant: if v[i] = 0 for each i ```<``` __n__ - k, then the remaining entries of v are set so to minimize the cost and satisfy demands of the vertices i ```>=``` __n__ - k.\n\nAssume that we have executed k steps, and now we are executing the (k+1)-step. Let i = n - (k + 1).\n\nIf i is a leaf, then we set v[i] = __d__[i]. (This value might be updated later.)\n\nIf i is a non-leaf, in this step we will eventually have to set v[i] >= d[i], as the only way to satisfy the demand of i is to let v[i] being at least __d__[i]. Also, the descendants of i have already satisfied their demands even if v[i] equals 0. So, when we increase v[i], it means that some of v[j], where j is a descendant of i, could potentially be reduced. But v[j] of which descendants?\n\nWe repeat the following:\n\nLet S_i be the set of all descendants of i such that for each descendant w all the values of the vertices on the path between w and i (excluding w and i) is zero.\n\n1. If v[i] >= d[i] and sum_{w in S_i} c[w] < c[i]\n2. Update v[w] = v[w] - 1 for each w in S_i\n3. Update v[i] = v[i] + 1.\n4. break\n\nClearly, this process does maintain the invariant that the demands of all the vertices [i+1, n-1] are satisfied. Furthermore, the demand of vertex i is satisfied as well, as the updates will continue as long as v[i] < __d__[i]. But, is the choice of S_i the best one?\n\nNamely, consider the following example. Vertex i has a direct child 2, and 2 has two direct children 0 and 1. Assume that each v[0], v[1] and v[2] is at least 1. When we increase v[i] by 1, instead of decreasing v[2] by 1 we could have as well decreased v[0] and v[1] by 1 without violating the demands. But, would decreasing v[0] and v[1] reduce the cost even further than decreasing only v[2]? If it would reduce the cost even further, then it would mean that c[0]+c[1] > c[2]. But now this violates our invariant that after the step when we processed vertex 2 the values were set optimally assuming that the unprocessed vertices have value 0. Namely, if c[0]+c[1]```>```c[2], an optimal solution should not keep both v[0] and v[1] positive as it pays off to increase v[2] by 1 and decrease each v[0] and v[1] by 1.\n\nIt is easy to generalize this argument in the following way. If we assume that in Step 1 it is better to choose a set of descendants {x_1, …, x_r} of w instead of w in S_i (and all the vertices x have positive v[x]), than it would imply that c[x_1]+...+c[x_r] > c[w]. But, again as before, this would contradict the invariant that when processing w the values in v are set optimally. (Notice that after a vertex i is processed and its value v[i] is set, in the further steps it never increases.)\n\nTo implement these steps efficiently, the official solution maintains a heap for each S_i together with the total cost of all the vertices that are in S_i. The heap for S_i is ordered by the current values of the vertices. In that way, after we update v[i] and need to reduce v[w] of w in S_i, it is easy to find the vertex in S_i that has the smallest value. Once v[w] get reduced to zero due to the updates, then we merge S_i and S_w. To do that efficiently, we should make sure to merge smaller to the larger heap.\nThe full implementation in Java is provided below.\n\n``` \nprivate class Pair implements Comparable {\npublic long first;\npublic int second;\nPair(long first, int second) {\nthis.first = first;\nthis.second = second;\n}\npublic int compareTo(Pair pair) {\nif (this.first < pair.first) return -1; else if (this.first > pair.first)\nreturn 1;\nelse {\nif (this.second < pair.second) return -1; else if (this.second > pair.second)\nreturn 1;\nreturn 0;\n}\n}\n}\nprivate ArrayList children[];\nprivate PriorityQueue heap[];\nprivate long[] sumOfCosts;\nprivate long[] valueToSubtract;\nprivate long[] value;\nprivate long totalCost;\nprivate long[] d, c, p;\nprivate void mergeFirstToSecondHeap(int f, int s) {\nwhile (heap[f].size() > 0) {\nPair p = heap[f].poll();\np.first = p.first - valueToSubtract[f] + valueToSubtract[s];\nheap[s].add(p);\n}\n}\npublic long minimumCost(int n, int[] op, int[] od, int[] oc, int[] params){\nd = new long[n];\nc = new long[n];\np = new long[n];\nfor (int i = 0; i < od.length; i++) {\nd[i] = od[i];\nc[i] = oc[i];\nif (i < op.length)\np[i] = op[i];\n}\nint t = od.length;\nfor (int i = t - 1; i <= n - 2; i++)\np[i] = (params[0] * p[i-1] + params[1]) % (i+1);\nfor (int i = t; i <= n - 1; i++)\nd[i] = 1 + ((params[2] * d[i-1] + params[3]) % params[4]);\nfor (int i = t; i <= n - 1; i++)\nc[i] = 1 + ((params[5] * c[i-1] + params[6]) % params[7]);\nchildren = new ArrayList[n];\nfor (int i = 0; i < n; i++)\nchildren[i] = new ArrayList();\nfor (int i = 0; i < n - 1; i++) children[(int)p[i]].add(i + 1); totalCost = 0; heap = new PriorityQueue[n]; sumOfCosts = new long[n]; valueToSubtract = new long[n]; value = new long[n]; for (int v = n - 1; v > -1; v--) {\nsumOfCosts[v] = 0;\nvalue[v] = 0;\nheap[v] = new PriorityQueue();\nfor (Integer child : children[v]) {\nsumOfCosts[v] += c[child];\nheap[v].add(new Pair(value[child], child));\n}\nlong increaseBy;\nwhile (true) {\nif (heap[v].size() == 0) {\nif (d[v] <= value[v])\nbreak;\nincreaseBy = d[v] - value[v];\n}\nelse if (c[v] < sumOfCosts[v])\nincreaseBy = heap[v].peek().first - valueToSubtract[v];\nelse if (value[v] < d[v])\nincreaseBy = Math.min(d[v] - value[v], heap[v].peek().first - valueToSubtract[v]);\nelse\nbreak;\ntotalCost += increaseBy * c[v];\ntotalCost -= increaseBy * sumOfCosts[v];\nvalue[v] += increaseBy;\nvalueToSubtract[v] += increaseBy;\nArrayList toMerge = new ArrayList();\nwhile (heap[v].size() > 0 && heap[v].peek().first == valueToSubtract[v]) {\nPair p = heap[v].poll();\ntoMerge.add(p);\nsumOfCosts[v] -= c[p.second];\n}\n// Merge the heaps.\nfor (Pair p : toMerge) {\nint u = p.second;\nsumOfCosts[v] += sumOfCosts[u];\nif (heap[u].size() <= heap[v].size())\nmergeFirstToSecondHeap(u, v);\nelse {\nmergeFirstToSecondHeap(v, u);\nheap[v] = heap[u];\nvalueToSubtract[v] = valueToSubtract[u];\n}\n}\n}\n}\nreturn totalCost;\n}\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"AyICjsAGXwAhfNqR9a8kM","type":"Entry","createdAt":"2020-03-30T23:06:14.883Z","updatedAt":"2020-03-30T23:06:14.883Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"boba5551","tcHandle":"boba5551"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-744-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"12j1nM0nxCztTLnCzJActT","type":"Entry","createdAt":"2020-04-20T12:41:36.583Z","updatedAt":"2026-02-23T23:28:13.251Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":53,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 713","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["C++","Java"],"creationDate":"2017-05-04T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 713 Editorials\n\nWe now have some of the SRM 713 Editorials published. We are awaiting or reviewing the submissions for some of them. If you would like to contribute an editorial for those problems you may do so by submitting to their respective challenge.\n\nThanks to __[stni](https://profiles.topcoder.com/stni)__, __[pakhandi](https://profiles.topcoder.com/pakhandi)__, __[marcose18](https://profiles.topcoder.com/marcose18)__ , __[GoogleHireMe](https://profiles.topcoder.com/GoogleHireMe)__ for contributing to the SRM 713 editorials.\n\n## Single Round Match 713 Round 1 - Division II, Level One SymmetryDetection by pakhandi\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14574)\n\nThe problem can be solved by traversing the matrix and checking for symmetry in a greedy / ad-hoc way.\nLet us first solve the problem for the vertical-symmetry.\nWe want to check if, for every cell [i][j], if it is equal to [i][cols - j - 1]. In this case we don't need to visit every cell. We only need to check this condition for cells in all the rows but only half the columns. The proof of this optimization is very trivial and is left as an exercise for the reader.\nFor the horizontal-symmetry, we can use the same method for all the columns but half the rows, comparing [i][j] with [rows - i - 1][j].\nThe method is very similar to what is used for checking palindrome.\nPlease check the implementation below for details.\n```\nclass SymmetryDetection\n{\npublic:\nstring detect(vector board)\n{\nbool h = 1, v = 1;\nint rows = board.size();\nint cols = board[0].size();\nfor(int i = 0; i < rows; i++)\n{\nfor(int j = 0; j <= cols / 2; j++)\n{\nif(board[i][j] != board[i][cols - j - 1])\n{\nv = 0;\n}\n}\n}\nfor(int i = 0; i <= rows / 2; i++)\n{\nfor(int j = 0; j < cols; j++)\n{\nif(board[i][j] != board[rows - i - 1][j])\n{\nh = 0;\n}\n}\n}\nif(h && v)\n{\nreturn \"Both\";\n}\nelse if(h)\n{\nreturn \"Horizontally symmetric\";\n}\nelse if(v)\n{\nreturn \"Vertically symmetric\";\n}\nelse\n{\nreturn \"Neither\";\n}\n}\n};\n```\n\n## Single Round Match 713 Round 1 - Division II, Level Two PowerEquationEasy by marcose18\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14573)\n\nIn this question we will iterate through all the values & it’s powers which are less than n.\nNow we will calculate answer for a number i & it’s powers in one go. Now for some power of i, let’s assume i ^ x we have to calculate all such values where (i ^ x) ^ c = (i ^ y) ^ d such that c, d & i ^ y ```<=``` n. Now clearly x, y ```<=``` maxpow where i ^ maxpow ```<=``` n while i ^ (maxpow + 1) > n.\n\nAlso (i ^ x) ^ c = (i ^ y) ^ d implies x * c = y * d. In short (x / y) = (d / c).\nSo for fixed values of x, y we have to find c & d such that it satisfies above equation while it is also ```<=``` n. So to find such c & d, reduce x & y to it’s lowest form by dividing both x & y by gcd(x, y).\n\nNow it’s easy to see that total possible values = n / max(tempx, tempy) where tempx & tempy are x / gcd & y / gcd respectively. Do the above for all values of i and add it to answer. One final thing to note here is if i ```>``` sqrt(n) then it contains no power that is less than n i.e i ^ x = i ^ y only for x = y = 1. So each of them will contribute n to the final answer and thus we will loop only upto sqrt(n) instead of n.\n\nBelow is the code of above explanation.\n\nHere HashSet is used to keep track of visited numbers and their powers.\n\n```\nimport java.util.*;\nimport java.util.regex.*;\nimport java.text.*;\nimport java.math.*;\npublic class PowerEquationEasy {\n// Calculating gcd of two numbers.\nstatic int gcd(int a, int b) {\nif (a < b) {\nint temp = a;\na = b;\nb = temp;\n}\nif (b == 0) return a;\nreturn gcd(b, a % b);\n}\npublic int count(int n) {\nlong ans = n * 1L * n;\nlong mod = (long) 1E9 + 7;\nans %= mod;\nHashSet set = new HashSet<>();\n// Iterate through all values but not those which are stored in the hashset which are nothing but powers of earlier values and we have calculated answers for them before.\nfor (int i = 2; i * i <= n; i++) {\nif (set.contains(i)) continue;\nint maxpow = 0;\nint temp = i;\nwhile (temp <= n) {\n++maxpow;\nset.add(temp);\ntemp *= i;\n}\n// Find the answer for all x & y such that (i ^ x) ^ c = (i ^ y) ^ d.\nfor (int x = 1; x <= maxpow; x++)\nfor (int y = 1; y <= maxpow; y++) { int g = gcd(x, y); int tempx = x / g, tempy = y / g; ans += n / Math.max(tempx, tempy); while (ans >= mod) ans -= mod;\n}\n}\n// All numbers greater than sqrt(n) will have no power that is less than n and for each of them there will be ‘n’ identities.\nans += (n - set.size() - 1) * 1L * n;\nans %= mod;\nreturn (int) ans;\n}\n}\n\n```\n\n## Single Round Match 713 Round 1 - Division II, Level Three DFSCountEasy by GoogleHireMe\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14589)\n\nIn this problem, you have to calculate number of different paths to traverse the graph using depth first search.\n\nFirst of all, let’s try to set the possible upper bound for the answer. There are exactly N! (n-factorial) permutations of numbers from 1 to N. All of those sequences will be valid when we have a complete graph.\n\nSo, the maximal possible answer can reach 13! = 6227020800, and this means that a brute force (trying all the possible paths) wouldn’t fit into time bounds.\nTo solve this problem, we can use dynamic programming.\n\nIn every dynamic programming problem you have to detect four things:\n\na) define a state\n\nb) find a way to split the problem into subproblems\n\nc) define the base state: the subproblem for which you know the solution immediately, without splitting it into subproblems.\n\nd) find a way to combine the subproblems’ solutions to get the solution of the main problem\n\nLet’s tackle this step by step:\n\na) Let’s define our problem’s state as a pair of , where start_node is the node from which we start building the path, and available_nodes - set of nodes which are not yet visited. Then, to find the solution to the initial problem, we would have to sum up all solutions of subproblems with all possible start nodes when all nodes as available.\n\nLet’s consider the following example:\n\nnode 1 is not available (since it was visited before) and start_node is 2;\n\nState: start_node=2, available_nodes={3, 4, 5, 6, 7, 8, 9}\n\n![SRM 713 01](//images.ctfassets.net/piwi0eufbb2g/58njTIA86X7xrOJwQ6jxm6/74d7a28f0bb83dcf724314f6e7093c72/SRM_713_01.webp)\n\nb) To split the problem into subproblems, we can just try to extend our existing path and make a one DFS call to one of the available\n\nIn the example, we can go to the next possible subproblems (2 is no longer available, start_node highlighted with blue color):\n\n![SRM 713 02](//images.ctfassets.net/piwi0eufbb2g/4IqKOb0I6TwLznImQHS7xd/3514d5cf0322e1ff4dd4eebb914856d1/SRM_713_02.webp)\n\n![SRM713 03](//images.ctfassets.net/piwi0eufbb2g/3M0SDaqXEt130XTdR1KsdO/5a6c26820e5b2d27a40e598989d28ff2/SRM713_03.webp)\n\n![SRM713 04](//images.ctfassets.net/piwi0eufbb2g/1fPK75bmwibkinSgCGxJpm/c94195fa88f4f75de313bc7d664fe93e/SRM713_04.webp)\n\n![SRM713 05](//images.ctfassets.net/piwi0eufbb2g/5HIYpuCYGVYawo109HnX7p/352d7dc4a45c5c55d274f7617ffa73bf/SRM713_05.webp)\n\nc) The base state can be the state with only one available node - it means that there is nowhere else to go, and the answer is 1 (only that node, and that’s the end).\nd) Now, we have to find a way to combine the solutions to the subproblems. And this is the place where things get really interesting:\n\nThe first thing we should notice is that once we decided which child to go next, all other children that are connected (directly or via available nodes) will not be available once the dfs() will return, since they will be marked as used in one of the dfs()’s subcalls of the call on that child.\n\nFor instance, in the example above, when we call dfs for node 3 from the node 2, it will mark nodes 4, 5 and 6 as used. Thus, after the end of the call, we wouldn’t be able to call dfs for the node 6 from the node 2 anymore.\n\nLet’s call the subset of the “reachable” nodes as the component.\n\nIn the example above, once we consider node 2 as start_node and node 1 as unavailable, we will have to components: consisting of nodes {3, 4, 5, 6} and {7, 8, 9}.\nSince you can pick only one node per component to move to, the number of dfs() calls from the start_node equals to the number of components in that state.\n\nSince the components are independent from each other, the result for the given state will be the multiplication of number of paths for all components separately.\n\nAlso, because of the independance of those components (you cannot reach one from another), we can do those above mentioned dfs() calls in any order, that means that we have to multiply the result by K! (k-factorial) where K is the number of components for the current state.\nOne more thing we still have to consider - what if one component contains more than one neighbour of the start_node. Since we can “enter” the component only once (after that all nodes of the component will be marked as used), the number of different paths for the component will be the sum of those subproblems with different children as start_node.\n\nA few notes on the implementation: the recursive solution looks nice, however, to avoid solving the same subproblem multiple times, it’s important to implement this recursion with memoization of the answers for every state previously calculated. We can achieve this with map data structure.\n\nIn my solution I use breadth first search to find the components.\n\nAlso, I use the bitmask to represent available nodes instead of the set, since the number of the nodes is small, and bit operations are generally “cheaper” (in terms of performance) than the operations on the set. Here, 1 on the ith position of the binary representation of the mask variable means that the ith node is in available_nodes set.\n\nComplexity:\n\nLet n be equal to the number of nodes.\n\nIn the worst case, for every state (2^n * n) we will perform breadth first search ( O(n*n)) for every neighbor (n).\n\nThus O(2^n * n * n * n^2) = O( 2^n * n^4 )\n\nTo sum up, the solution will look like follows:\n```\n#include \n#include \n#include \n#include \nusing namespace std;\nclass DFSCountEasy {\nint n;\nvector G;\nmap, long long> cache;\nlong long f(int mask, int v) {\n// Remove current node from the available nodes\nmask = mask & (~(1 << v));\nif (cache.count({mask, v})) {\n// The solution for this subproblem was calculated before\nreturn cache[{mask, v}];\n}\nmap components;\nfor (int i = 0; i < n; i++) {\nif (G[v][i] == 'Y' && (mask & (1 << i))) {\n// BFS for child i\nqueue q;\nq.push(i);\n// Bitmask for the set of nodes included in the corresponding component\nint submask = 1 << i;\nwhile (!q.empty()) {\nint u = q.front();\nq.pop();\nfor (int j = 0; j < n; j++)\nif (mask & (1 << j)) {\nif (G[u][j] == 'Y' && !(submask & (1 << j))) {\nsubmask |= 1 << j;\nq.push(j);\n}\n}\n}\ncomponents[submask] += f(submask, i);\n}\n}\nlong long res = 1;\nfor (auto x : components) res *= x.second;\nfor (int i = 0; i < components.size(); i++) res *= i + 1;\nreturn cache[{mask, v}] = res;\n}\npublic:\nlong long count(vector _G) {\nG = _G;\nn = G.size();\nlong long res = 0;\nfor (int i = 0; i < n; i++) res += f((1 << n) - 1, i);\nreturn res;\n}\n};\n```\n\n## Single Round Match 713 Round 1 - Division I, Level One PowerEquation by stni\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14573)\n\n If a=c, b=d, we have n*n identities.\nHere, 1^1=1^2=1^3=...=1^n,----(n-1)\n1^2=1^1=1^3=...=1^n,----(n-1)\n...\n1^n=1^1=1^2=...=1^(n-1) ----(n-1)\nFor a=1 and b=1,\nwe need to add another n*n-1.\nSo we already have n*(2*n-1) identities obviously.\nFor a != c:\nWithout loss of generality, we say ac.\nFor all integers not power of other integers p,\nlet a=p^i, c=p^j\nnumber of c we can choose from equals to\nnumber of powers of least common multiple(LCM) of a and c.\nj/gcd(i,j) is the min distance between powers of LCM,\nn/(j/gcd(i,j)) is the number of such identities in [1..n]\nmultiply 2 for symmetry of a-c, b-d\nComplexity is O(n)\n\n```\n#include\nusing namespace std;\ntypedef long long ll;\nconst ll mod=1e9+7;\nll gcd(ll a,ll b){\nreturn a?gcd(b%a,a):b;\n}\nclass PowerEquation{\npublic:\nint count(int n0){\nll n=n0;\nsetse; //all power bases\nll ans=n*(n*2-1)%mod;\nfor(ll p=2;p*p<=n;p++){\nif(se.count(p))\ncontinue; //we already calculated p's base\nll t=p;\nll k=0;//number of powers of t\nwhile(t<=n){\nse.insert(t);\nt*=p;\nk++;\n}\nfor(ll i=1;i<=k;i++){\nfor(ll j=i+1;j<=k;j++){\nans+=n/(j/gcd(i,j))*2;\nans%=mod;\n}\n}\n}\nreturn (int)ans;\n}\n};\n\n```\n## Single Round Match 713 Round 1 - Division I, Level Two DFSCount by stni\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14588)\n\nWe use an 15-bit integer to remember which nodes we visited during the dfs process. If we have visited the i-th node, we set the i-th bit to 1. If it is not visited, the i-th bit is set to 0. We need a dfs function with two parameters.\n\nThe parameters being an integer as the 15-bit integer and an integer which keeps the last visited node.\n\nIn dfs:\n\nIf all nodes connected to the last node are visited -there is only 1 way to do dfs which is \"to do nothing and return\".\n\nIf there is a node i connected to this node and not visited, -we can append i to p.\n\nWe dfs with node i as last visited node, get the number of ways we can do dfs, and 15-bit visited nodes. We get the second integer which shows the nodes we visited from i. If we do the dfs again from last node with parameter visited being the newly returned visited integer.\n\nThe ways to do dfs from last node is to multiply these 2 returned values because 2 orders exist. Suppose nodes visited in the first dfs are n1, nodes visited in the second dfs are n2.\n\nWe can visit n1 then visit n2, so after i we append n1 then n2 to p.\n\nWe can also visit n2 then n1, so after i we append n2 then n1 to p.\n\nThey all start from last node, and n1 includes node i. If we have a set of nodes not visited and we visited node last, the number of ways we can do dfs is always the same. So we memoize that in a 2D vector to avoid repeated calculations. The first dimension is all 15-bit integer which stores the visited nodes, size 1<\n#include\n#include\nusing namespace std;\ntypedef long long ll;\nvectorG;\nvector, 15>>mem;\nclass DFSCountEasy{\npublic:\npair dfs(ll visited, ll last){\nif(mem[visited][last].second)return mem[visited][last];\npair r(0,0);\nfor(int i=0;it1=dfs(visited|(1<t2=dfs(t1.second,last);\nr.first+=t1.first*t2.first;\nr.second=t1.second|t2.second;\n}\nif(r.second==0){\nr=make_pair(1, visited);\n}\nreturn mem[visited][last]=r;\n}\nll count(vectorG){\n::G=G;\nmem.clear();\nmem.resize(1< r=dfs(0,G.size());\nreturn r.first;\n}\n};\n\n```\n\n## Single Round Match 713 Round 1 - Division I, Level Three CoinsQuery\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/14572)\n\nWe are awaiting the submission for the following editorial. If you would like to contribute an editorial for this problem you may do so by submitting to this challenge.","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"14TE3B3pQi9gHoiwEwT1M0","type":"Entry","createdAt":"2019-09-03T05:38:25.068Z","updatedAt":"2021-02-01T15:48:12.785Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":14,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"Harshit Mehta","email":"harshit@topcoder.com","tcHandle":"hmehta","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4YytE3oNPvlye512WD73FD","type":"Asset","createdAt":"2019-09-03T05:38:20.793Z","updatedAt":"2019-09-03T05:38:20.793Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":4,"revision":1,"locale":"en-US"},"fields":{"title":"hmehta-1460012668303","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/4YytE3oNPvlye512WD73FD/7ec8bc9abcb19e57421595ff6f21c8ab/hmehta-1460012668303.jpeg","details":{"size":187321,"image":{"width":1185,"height":1185}},"fileName":"hmehta-1460012668303.jpeg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-713-editorials"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2Za1IjpWC9KMeZYrWS1Zr0","type":"Entry","createdAt":"2020-04-20T12:42:12.823Z","updatedAt":"2026-02-17T00:02:49.691Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":46,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 738","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Java"],"creationDate":"2018-09-30T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 738 Editorials\n\nThe round was held on 30th Sept, 2018. Thanks to [wild_hamster ](https://profiles.topcoder.com/wild_hamster)for the interesting problem set and editorials. Thanks to [Petr](https://profiles.topcoder.com/petr) for recording his screen during the round. Click here to see Petr's screencast of the round.\n\n## Div2Easy: DriveTheCarEasy\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15106)\n\nIncreasing speed by speed __i__ before the second moments __i__ leads to increase speed by speedi during S-momentsi+1 seconds. So for each pair speedi, momentsi we need to add __S-moments i+1__ * __speed__ __i__ to the answer.\nCode:\n\n```\npublic class DriveTheCarEasy {\npublic long calculateDistance(int S, int N, int[] speed_changes, int[] moments) {\nlong ans = 0;\nfor (int i = 0; i < N; i++)\nans += (long)(S - moments[i] + 1) * speed_changes[i];\nreturn ans;\n}\n```\n\nTime complexity O(N).\n\n## Div2Medium: EnergySource\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/15107)\nThere can be at most 10^5 possible divisions under given constraints. We can generate all of them recursively. For each division, we can take every element not equal to 1 and try to split this element it into g > 1 new elements and go recursively to the new generated division if we didn't already visit it recursively. Doing it straightforward will not fit in TL, so there are possible ways to fit in TL:\n1. Precalculate all values from 1 to 90 inclusive.\n2. Remember not all the elements of the division, but for each distinct element, we can remember the only number of occurrences of it in a division.\n3. Precalculate divisors of each number from 1 to 90 and for each element in the division we can try to split it only in the number of divisors parts.\n\n```\nimport java.util.*;\npublic class EnergySource {\nlong ans1 = 0;\nlong ans2 = 0;\nint itr = 0;\nArrayList[] divisors = new ArrayList[105];\nArrayList g = new ArrayList();\nHashSet f = new HashSet();\nint[] get_idx = new int[105];\nint[] cur_divisors = new int[105];\nlong get() {\nint sz = g.size();\nlong ans = 0, mul = 1;\nfor (int i = sz-1; i>= 0; i--) {\nans += mul*(g.get(i)+1);\nmul *= (cur_divisors[sz-i-1]+2);\n}\nreturn ans;\n}\nvoid go() {\nitr++;\nif (f.contains(get())) {\nreturn;\n}\nf.add(get());\nans1++;\nlong cur = 1;\nfor (int i = 1; i < g.size(); i++) {\nfor (int j = 0; j < g.get(i); j++)\ncur *= cur_divisors[i];\n}\nans2 += cur;\nfor (int i = 1; i < g.size(); i++) { if (g.get(i) > 0) {\nfor (int j = 1; j < divisors[cur_divisors[i]].size(); j++) {\nint cur_div = divisors[cur_divisors[i]].get(j);\nint diff = cur_divisors[i]/cur_div;\ng.set(get_idx[diff], g.get(get_idx[diff]) + cur_div);\ng.set(i, g.get(i)-1);\ngo();\ng.set(i, g.get(i)+1);\ng.set(get_idx[diff], g.get(get_idx[diff]) - cur_div);\n}\n}\n}\n}\nvoid solve(int n) {\nfor (int i = 1; i < divisors[n].size(); i++) {\ng.add(0);\n}\ng.add(1);\nfor (int i = 0; i < divisors[n].size(); i++) {\nget_idx[divisors[n].get(i)] = i;\ncur_divisors[i] = divisors[n].get(i);\n}\ngo();\n}\npublic long[] countDifferentSources(int power) {\nfor (int n = 1; n<= 100; n++) {\ndivisors[n] = new ArrayList();\nfor (int i = 1; i<= n; i++)\nif (n % i == 0) {\ndivisors[n].add(i);\n}\n}\nsolve(power);\nlong[] ans = {ans1, ans2};\nSystem.out.println(f.size());\nreturn ans;\n}\n}\n```\n\n## Div2Hard: MovingByPoints\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15108)\n\nFor any pair of points (x1, y1), (x2, y2) the minimal number of added points between them needed to get from one point to another not using another given points is equal to |x2-x1|+|y2-y1|-1.\nLet¢s define every point as node of graph and make edge between any pair of points with distance equal to distance between points. After that we can use Dijkstra to find the shortest path between 1 and N.\n\n```\npublic class MovingByPoints {\nint d[][] = new int[1005][];\nint w[] = new int[1005];\nint used[] = new int[1005];\nint Abs(int x) {\nreturn (x>0?x:-x);\n}\npublic int countMinimumPoints(int N, int[] X, int[] Y) {\nfor (int i = 0; i < N; i++)\nd[i] = new int[1005];\nfor (int i = 0; i < N; i++)\nfor (int j = 0; j < N; j++)\nd[i][j] = Math.max(0, Abs(X[j] - X[i]) + Abs(Y[j] - Y[i]) - 1);\nfor (int i = 0; i < N; i++)\nw[i] = 1000000000;\nw[0] = 0;\nfor (int i = 0; i < N; i++) {\nint min1 = 1000000000;\nint idx = -1;\nfor (int j = 0; j < N; j++) {\nif (used[j] == 0 && w[j] < min1) {\nmin1 = w[j];\nidx = j;\n}\n}\nused[idx] = 1;\nfor (int j = 0; j < N; j++) {\nw[j] = Math.min(w[j], w[idx] + d[idx][j]);\n}\n}\nreturn w[N-1];\n}\npublic String checkData(int N, int[] X, int[] Y) {\nif (N < 1 || N > 500) {\nreturn \"N must be between 1 and 500, inclusive.\";\n}\nif (X.length != N || Y.length != N) {\nreturn \"X and Y must have exactly N elements.\";\n}\nfor (int i = 0; i < N; i++) {\nif (X[i] < 1 || X[i] > 1000000 || Y[i] < 1 || Y[i] > 1000000) {\nreturn \"Each element of X and Y must be between 1 and 10^6, inclusive.\";\n}\n}\nreturn \"\";\n}\n}\n```\n\nTime complexity O(N^2)\n\n## Div1Easy: FindThePerfectTriangle\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15109)\n\nWe can notice, that if one of the sides of the triangle will be irrational number, than perimeter will be irrational too. So we need to find all possible such vectors (vx, vy), where vx^2+vy^2 = k^2) (for some positive integer k £ P, vx and vy are integers). We will call such vectors good vectors.\n\nThere will be not many such vectors(not more than 10^4). We can construct two sides of the triangle using good vectors (vx1, vy1) and (vx2, vy2) on such set of points:\n0, 0, vx1, vy1, vx1+vx2, vy1+vy2 ((vx1+vx2, vy1+vy2) must be also good vector).\n\nIn that way we can construct all possible triangles with integer coordinates, integer area and integer perimeter. After that we can check if (P, S) belongs to that possible triangles.\n\n```\npublic class FindThePerfectTriangle {\nint[] a = new int[1005000];\nint[][] good = new int[1005][];\nint mx[] = new int[5005];\nint my[] = new int[5005];\nint segment_sz = 0;\nint Abs(int x) {\nreturn (x>0?x:-x);\n}\nint S(int x1, int y1, int x2, int y2, int x3, int y3) {\nint ans = (x1+x2)*(y1-y2)+(x2+x3)*(y2-y3)+(x3+x1)*(y3-y1);\nreturn Abs(ans);\n}\npublic int[] constructTriangle(int area, int perimeter) {\nfor (int i = 0; i <= 1000000; i++)\na[i] = 0;\nfor (int i = 1; i <= 1000; i++) {\na[i*i] = i;\n}\nfor (int i = 0; i <= 1000; i++) {\ngood[i] = new int[1005];\nfor (int j = 0; j <= 1000; j++) {\ngood[i][j] = 0;\n}\n}\nfor (int i = 0; i <= 1000; i++) {\nfor (int j = 0; j <= 1000; j++) {\nint x = i*i + j*j;\nif (x <= 1000000 && a[x] > 0) {\nmx[segment_sz] = i;\nmy[segment_sz] = j;\ngood[i][j] = good[j][i] = a[x];\nsegment_sz++;\n}\n}\n}\nfor (int i = 0; i < segment_sz; i++) {\nfor (int j = 0; j< segment_sz; j++) { int x1 = mx[i] + mx[j]; int y1 = my[i] + my[j]; int ar = S(0, 0, mx[i], my[i], x1, y1); if (ar > 0 && ar % 2 == 0 && x1 <= 1000 && y1 <= 1000 && good[x1][y1] > 0) {\nint P = good[mx[i]][my[i]] + good[mx[j]][my[j]] + good[x1][y1];\nif (P == perimeter && ar/2 == area) {\nint[] ans = {1, 1, mx[i]+1, my[i]+1, x1+1, y1+1};\nreturn ans;\n}\n}\nx1 = mx[i] - mx[j];\ny1 = my[i] + my[j];\nar = S(0, 0, mx[i], my[i], x1, y1);\nif (ar > 0 && ar % 2 == 0 && Abs(x1) <= 1000 && y1 <= 1000 && good[Abs(x1)][y1] > 0) {\nint P = good[mx[i]][my[i]] + good[mx[j]][my[j]] + good[Abs(x1)][y1];\nif (P == perimeter && ar/2 == area) {\nint x = Math.max(1, -x1+1);\nint[] ans = {x, x, mx[i]+x, my[i]+x, x1+x, y1+x};\nreturn ans;\n}\n}\n}\n}\nint[] ans = {};\nreturn ans;\n}\nint find_int_dist(int x1, int y1, int x2, int y2) {\nint dist = (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1);\nfor (int i = 1; i <= 5000; i++) if (i*i == dist) return i; return -1; } boolean in_range(int x) { return (x >= 0 && x <= 3000);\n}\n}\n```\n\n## Div1Medium: LightBulbGame\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/15112)\nAs this is a combinatorial game and the state space is too large to solve it using brute force, we have to look for a more clever solution. One of the traditional tools that often works is the Sprague-Grundy theory that can be efficiently applied whenever the game can be split into a collection of independent smaller games.\n\nThe main challenge in this problem was to realize that this is indeed the case here. At the first glance, this is not obvious because it seems that the lightbulbs cannot be independent if you can sometimes turn two of them off in one move.\n\nImagine that instead of lightbulbs we play the game with pebbles: add a pebble instead of turning the lightbulb on, and remove a pebble instead of turning it off. Then, \"just turning lightbulb L off\" is the same as \"just removing the pebble from L\". I now claim that \"turning off L and toggling L'\" is equivalent to \"moving a pebble from L to L'\".\n\nWhy is that the case? If I turned L' on, the equivalence is obvious. If I turned L' off, I now have two different situations: in the lightbulb game the lightbulb is off, while in the pebble game I now have two pebbles at L'.\n\nWhy are these two situations equivalent? Because the two pebbles at the same location can safely be ignored, as if they weren¢t there. More precisely, imagine the two pebbles are not there and find out which player has the winning strategy. That player still has a winning strategy if we add those two pebbles back. Said strategy: follow the original strategy with the original pebbles, and copy your opponent's moves on the two extra pebbles.\n\nThus, we can use simple dynamic programming to compute the Sprague-Grundy value for each lit lightbulb, xor them to get the Sprague-Grundy value of the entire board, and then we can examine all\npossible first moves and evaluate each of them independently.\n\n```\nimport java.util.*;\npublic class LightbulbGame {\npublic int countWinningMoves(String[] board) {\nint R = board.length, C = board[0].length();\nint[][] SG = new int[R][C];\nfor (int r=R-1; r>=0; --r) for (int c=C-1; c>=0; --c) {\nHashSet reachable = new HashSet();\nreachable.add(0);\nfor (int nr=r+1; nr= 261 and distance £ 30000 we can construct an array of increasing speed for each second consisting only with zeros and ones without even adding 2 to the array and calculate the answer as the number of ones in the array.\n\nThis is because:\n1. You can always take a smaller value in the last iteration of the adding one to the array to produce the exact distance you need. That solution is clearly the optimal solution that only uses speedup by 1.\n2. For these constraints you never need to increase your speed by more than 1. This is because for time ³ 261 even if you use the above greedy for distance = 30000, the three largest unused effects of a speedup by 1 will still be at least as large as the effect of changing the speedup at the beginning from 1 to 2.\n\nNow we need to solve the problem for (time+1)* time/2 < distance. Let's try to solve this problem in non-integer values:\nIf we need to move for distance meters in time seconds, the total distance travelled will be equal to\n```time*x1 + (time-1)* x2 + (time-2)*x3 + ... + 1*xtime,```\nfor time*x1 meters will be wasted x1^2 fuel, for (time-1)* x2 will be wasted x2^2 fuel and so on.\nTo minimize the amount of used fuel we need to maximize the amount of meters travelled for 1 unit of fuel. So we need to maximize values time/x1,\n\n(time-1)/x2, (time-2)/x3, ¼, 1/xtime and they all must be equal.\n\nWe have x1 = time*x, x2 = (time-1)*x, ¼ ,xtime = 1*x, and x1*time + x2*(time-1) + ¼ + xtime*1 = distance, leading to x*(1^2+2^2+¼+time^2) = distance, and minimal amount of fuel is equal to x^2*(1^2+2^2+...+time^2) = distance^2/(1^2+...+time^2).\n\nNow we can calculate this values for all distance £ 30000 and time £ 261 and compare it with dp[time][distance] counted in O(distance^2*log(distance)) and find out that the maximum difference is 30.\n\nWe also can get that for dp[time][distance] the optimal K taken in double value in dp[time-1][distance-K*time]+K*K is equal to x1 = time* x = 6* distance/((time+1)* (2 * time+1)).\nValues of dp[time-1][distance-K*time]+K* K in double values will be monotonous sequence on segments [K, +infinity) and (-infinity, K], so we can iterate K down and up in integer while dp[time-1][distance-K*time]+K*K will be not bigger than optimal_double_solution(time, distance) + 30 and it leads to less than 10^8 operations for distance £ 3*10^4.\n\n```\npublic class DriveTheCarHard {\nint dp[][] = new int[305][];\ndouble calc(int i, int j) {\nreturn (1.*j*j/(1.*(i)*(i+1)*(2*i+1)/6));\n}\nint solve_fast(int x, int y) {\nfor (int i = 1; i <= 30000; i++)\ndp[1][i] = i*i;\nfor (int i = 2; i <= 250; i++)\nfor (int j = 1; j <= 30000; j++)\ndp[i][j] = 1000000000;\nint cnt = 0;\nfor (int i = 2; i <= 250; i++) {\nfor (int j = 0; j <= 30000; j++) { double pre = calc(i,j); int optK = (int)(6.*j/(1.*(i+1)*(2*i+1))); for (int k = optK; j-k*i >= 0; k++) {\nif (dp[i-1][j-k*i] + k*k < pre + 30) { dp[i][j] = Math.min(dp[i][j], dp[i-1][j-k*i] + k*k); } else { break; } } for (int k = optK; k >= 0; k--) {\nif (dp[i-1][j-k*i] + k*k < pre + 30) { dp[i][j] = Math.min(dp[i][j], dp[i-1][j-k*i] + k*k); cnt++; } else { break; } } } } return dp[x][y]; } int solve_over_sqrt(int T, int D) { int cur_cnt = T; int[] ones = new int[1050]; int cur_sz = 0; while (D > 0) {\nint val = Math.min(D, cur_cnt);\nD -= val;\nones[cur_sz++] = val;\ncur_cnt--;\n}\nint ans = cur_sz;\nint pnt = 0;\nint left = 0;\nwhile (true) {\nif (cur_sz < 3) break; int sz = cur_sz; if (ones[pnt]+left >= ones[sz-1] + ones[sz-2] + ones[sz-3]) {\nleft += ones[pnt];\n} else {\nbreak;\n}\nans += 3;\nwhile (ones[cur_sz-1] <= left) {\nleft -= ones[cur_sz-1];\ncur_sz--;\nans--;\n}\npnt++;\n}\nreturn ans;\n}\npublic int findMinimumFuel(int total_time, int distance) {\nfor (int i = 0; i < 300; i++)\ndp[i] = new int[30500];\nif (total_time <= 250) {\nreturn solve_fast(total_time, distance);\n}\nreturn solve_over_sqrt(total_time, distance);\n}\n};\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"4ABel2vbHUvb15mFn3rKae","type":"Entry","createdAt":"2020-04-20T12:42:12.778Z","updatedAt":"2020-04-20T12:42:12.778Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":1,"revision":1,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"wild_hamster","tcHandle":"wild_hamster"}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-738-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2PvvgbYEo6LIraJBv7pQVF","type":"Entry","createdAt":"2020-04-20T12:42:12.708Z","updatedAt":"2026-02-16T23:46:12.801Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":34,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 737","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Python","Java"],"creationDate":"2018-09-19T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 737 Editorials\n\n## Make737Easy\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15070)\n\nThe problem has a straightforward solution: with the constraints being so low, we can afford an O(n^3) solution that simply enumerates and checks all triples of indices.\n\n```\ndef count(S):\nanswer = 0\nfor i in range( len(S) ):\nfor j in range( i+1, len(S) ):\nfor k in range( j+1, len(S) ):\nif S[i]=='7' and S[j]=='3' and S[k] == '7':\nanswer += 1\nreturn answer\n```\n\nMore efficient solutions exist as well. In fact, the problem is solvable in linear time. The main idea of one such algorithm: For each ‘3’ we can count the number of 737-triples that contain it by multiplying the number of ‘7’s to its left and the number of ‘7’s to its right.\n\n```\ndef count_linear(S):\n# compute the following:\n# prefix[i] is the number of '7's in the first i characters of S\n# suffix[i] is the number of '7's in the last i characters of S\nN = len(S)\nprefix, suffix = [0], [0]\nfor n in range(N):\nprefix.append( prefix[-1] + (1 if S[n]=='7' else 0) )\nfor n in range(N-1,-1,-1):\nsuffix.append( suffix[-1] + (1 if S[n]=='7' else 0) )\n# use the precomputed values to calculate the number of 737-triples\nreturn sum( prefix[n] * suffix[N-n-1] for n in range(N) if S[n]=='3' )\n```\n\n## AliceAndBobMedium\n[Problem Details\n](https://archive.topcoder.com/ProblemStatement/pm/15073)\nA winning move for Alice is a move that will get Bob into a losing position. And as we know from the problem statement, losing positions are those in which the bitwise xor of all pile sizes is zero.\n\nThe pile sizes in the input are quite large, so we cannot afford to enumerate all possible moves Alice can make. In order to solve this task, we need to make one observation: for each pile there is at most one winning move.\nWhy is that the case? Consider the following example. Suppose the current pile sizes are {7, 5, 3, 4}.\n\nWhat happens if Alice chooses the pile with 7 stones? By removing some of them, she will create a new state in which the pile sizes are {x, 5, 4, 3} for some x < 7. In order for this to be a winning move, we are looking for a value x such that (x xor 5 xor 4 xor 3) = 0.\n\nNow we can easily see that there is exactly one such x: x = (5 xor 4 xor 3) = 2. In other words, Alice’s winning move is to go from {7, 5, 3, 4} to {2, 5, 3, 4}.\n\nIn the same example, suppose Alice chooses the pile with 3 stones. Using the same math as above, we can compute that the desired new pile size is x = (7 xor 5 xor 4) = 6. However, this is not a valid move for Alice: she cannot go from 3 stones to 6, as she can only remove stones.\nThis observation can easily be generalized. In order to count the winning moves for Alice, we just do the following: For each pile p, compute x = the bitwise xor of all other piles. If x < p, Alice has a winning move on this pile, otherwise she doesn’t.\n\n```\ndef count(A):\nxorall = 0\nfor a in A: xorall = xorall ^ a\nwinning = 0\nfor a in A:\nneeded = xorall ^ a\nif needed < a: winning += 1\nreturn winning\n```\n\n## SimpleMathProblem\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15075)\n\nThere are multiple ways to tackle this problem. I tried to choose one that has a small number of special cases.\n\nOur goal is to compute a^(b^c) modulo m. The two main tools for such jobs are:\nhttps://en.wikipedia.org/wiki/Euler%27s_theorem that can be used if a and m are coprime\nhttps://en.wikipedia.org/wiki/Chinese_remainder_theorem that can be used to split the computation “modulo m” into computations using other smaller moduli.\n\nOur plan of attack will be as follows. We’ll start by finding the prime factorization of m. For each p^k that is a factor of m:\n- If a is not divisible by p, we can use Euler’s theorem to compute a^(b^c) mod p^k.\n- If a is divisible by p and b^c >= k, we know that a^(b^c) mod p^k = 0.\n- If a is divisible by p and b^c < k, we can compute a^(b^c) mod p^k directly.\n\nFinally, we just use the Chinese remainder theorem to merge all partial results into one. In my code, instead of using the actual CRT I use a simple implementation that runs in O(min(modulus1,modulus2)), which is fast enough in our case.\n\n```\ndef gcd(a,b):\nif b == 0: return a\nreturn gcd(b,a%b)\ndef factor(n):\nanswer = []\nd = 2\nwhile True:\nif d*d > n: break\nwhile n % d == 0:\nanswer.append(d)\nn //= d\nd += 1\nif n > 1:\nanswer.append(n)\nreturn answer\ndef phi(n):\nanswer = n\nfor p in set(factor(n)): answer = (answer * (p-1)) // p\nreturn answer\ndef modexp(a,b,c):\nif b == 0: return 1 % c\nt = modexp(a,b//2,c)\nanswer = t*t*(a if b%2 else 1)\nreturn answer % c\ndef crt_combine(a1,m1,a2,m2):\nif m1 < m2: a1, m1, a2, m2 = a2, m2, a1, m1 for k in range(m2): if (a1 + k*m1) % m2 == a2: return a1 + k*m1, m1*m2 def calculate(a,b,c,m): answer, modulo = 0, 1 for p in set(factor(m)): curmod = 1 while m % p == 0: curmod, m = curmod*p, m//p if a%p == 0: if b == 1: newexp = 1 elif b > 1 and c <= 10: newexp = min(50,b**c)\nelse: newexp = 50\ncurans = modexp(a,newexp,curmod)\nelse:\nnewexp = modexp(b,c,phi(curmod))\ncurans = modexp(a,newexp,curmod)\nanswer, modulo = crt_combine(answer,modulo,curans,curmod)\nreturn answer\n```\n\n## AliceAndBobEasy\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15076)\n\nThe winning strategy for NIM is well-known: a position is losing if and only if the bitwise xor of all pile sizes is zero.\n\nIf we are in a losing position, there are no winning moves. If we are in a winning position, a winning move puts our opponent into a losing position. Thus, we want to make the bitwise xor of all piles be equal to zero. In other words, we need to choose one pile and make its size equal to the bitwise xor of all other piles.\n\nHence, in any given winning position there is at most one winning move on each pile. Note the “at most”. This is because sometimes the size we need is bigger than the size we have, which is not a valid move. For example, in the winning position {7, 5, 3, 4} there is no winning move on the pile with 3 stones because we would need to go to {7, 5, 6, 4} and we are not allowed to add stones.\n\nThus, for any n we see that a winning position with n piles has at most n distinct winning moves. If we can find such positions, we can be sure that they are optimal.\n\nFor odd n such positions are easy to find. For example, consider the position { 2^x + 1, 2^x + 2, …, 2^x + n } for some x such that 2^x > n. We can easily verify that there is a winning move on each pile. This is because the bitwise xor of any n-1 piles will not have the 2^x bit set (as n-1 is even), and therefore it will certainly be smaller than the current number of stones on the remaining one pile.\n\nFor even n the best we can do are positions with n-1 winning moves, for example { 1, 2^x + 1, 2^x + 2, …, 2^x + n-1 }. Using the same reasoning as above we can show that there is a winning move on each pile other than the “1” pile. All that remains is to show that we cannot do better.\nSuppose n is even and we are in a winning position. As the bitwise xor of pile size is non-zero, let x be the largest exponent of two that appears in said bitwise xor. As the total number of piles is even and the number of piles that have the x-th bit set is odd, there has to be a pile P that doesn’t have the x-th bit set. We now claim that there is no winning move on pile P.\nWhy is that? Because the bitwise xor of all other piles will match P on all bits bigger than x, and it will have the x-th bit set while P doesn’t. Thus, the bitwise xor of piles other than P is greater than P.\n\n## GroupTheNumbers\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15078)\n\nHere are some observations we can make:\nThere is an optimal solution with at most one group that has a nonpositive value. (Otherwise we can combine two such groups into one.)\n\nIn any optimal solution there is only one group with value > 1. (Same argument.)\nLet’s call x big if abs(x) > 1. In any optimal solution, all big elements are in the same group, except for at most one negative big element. (The only other place they can be is the nonpositive group, if any. It is always better to bring all positive big elements, and any pair of negative big elements from the nonpositive group into the big positive group.)\nEach “1” should optimally be a separate group. (If we have it anywhere else it’s better to take it out.)\n\nPairs of “-1”s should never be together in a group with other numbers, each such pair should be a separate group. (Same argument.)\nThis leaves us with a small finite number of cases, and we can find the optimal solution by examining all of them and picking the best one. (It is possible to make further observations, e.g., which negative number to choose as the one that is not in the “big” group, but it’s not necessary.)\n\nThus, the outline of my final solution looks as follows:\nWrite a brute force solution that works for any small constant number of elements. (We will never use it on more than 4 elements. I did it this way because to me it was simpler than the additional casework.)\n\nMerge all 0s into a single 0.\nMake each 1 a separate group.\nMake each pair of -1s a separate group, as long as you have some -1s left over.\nIf the product of all big elements is positive, make them into a group.\nIf you now have no big elements, use brute force.\nIf the product of all big elements is negative and you have a -1, try making a group of all big elements + the -1, then use brute force.\nIf the product of all big elements is negative, also try all possibilities of making a group of them that is missing one negative element, and then use brute force.\n\n## Make737Hard\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15080)\n\nWe already made a useful observation in the linear solution for Make737Easy: given any string of 7s and 3s, the number of 737-triples can be counted as sum( (7s to my left) times (7s to my right) for each 3 in the string).\n\nWe can now imagine building the desired string in two steps: first we choose the number of 7s in the string, then we choose where to insert the 3s. Once we chose the number of 7s, each gap between them comes with some specific number of 737-triples each 3 inserted into that gap will produce. For example, each 3 inserted at the marked location in 777|77 will produce 3* 2 = 6 triples.\n\nThis can now be treated as a knapsack problem: we need to choose the right number of “items” so that their sum becomes exactly the given X.\n\nMy alternate solution for this problem feels a little like cheating. The number of strings in {3,7}^373 is huge, the number of triples in each of them is always small, and the “item sizes” in the knapsack are reasonably distributed. Thus the set of correct answers should always be large and fairly dense. Hence, all I did was a clever random walk that oscillates around the desired number of triples until it hits exactly.\n\n```\nstring make(int X) {\nif (X <= 371) return '7' + string(X, '3') + '7';\nstring curr = \"\";\nwhile (int(curr.size()) < 373 && eval(curr) < X + 20000)\ncurr += ((rand() & 1) ? '7' : '3');\nint currval = eval(curr);\nwhile (true) {\nstring cand = curr;\ncand[rand() % cand.size()] = ((rand() & 1) ? '7' : '3');\nint candval = eval(cand);\nif (candval <= currval && currval < X) continue; if (candval >= currval && currval > X) continue;\ncurr = cand;\ncurrval = candval;\nif (currval == X) return curr;\n}\n}\n```","featuredImage":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"6nCaCYxOpz6ody4U5cGIbd","type":"Asset","createdAt":"2019-09-18T22:05:07.141Z","updatedAt":"2021-09-13T03:51:41.089Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":90,"revision":14,"locale":"en-US"},"fields":{"title":"Topcoder Generic Banner","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/6nCaCYxOpz6ody4U5cGIbd/1b0d2bb3e83f8a58f2ffc9bcab941480/Banner_Thrive.png","details":{"size":160141,"image":{"width":455,"height":355}},"fileName":"Banner Thrive.png","contentType":"image/png"}}},"contentAuthor":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"15hZ81f4IwUr58BBvJwPrf","type":"Entry","createdAt":"2019-11-28T11:58:14.181Z","updatedAt":"2020-03-31T13:36:21.559Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":7,"revision":2,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"person"}},"locale":"en-US"},"fields":{"name":"misof","tcHandle":"misof","avatar":{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2E7acuXQQKFsBewSg1AxMG","type":"Asset","createdAt":"2020-03-31T13:36:18.289Z","updatedAt":"2020-03-31T13:36:18.289Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":3,"revision":1,"locale":"en-US"},"fields":{"title":"misof big","file":{"url":"//images.ctfassets.net/piwi0eufbb2g/2E7acuXQQKFsBewSg1AxMG/f8507d688787d65784dc2410d808d3f8/misof_big.jpg","details":{"size":3899,"image":{"width":126,"height":140}},"fileName":"misof_big.jpg","contentType":"image/jpeg"}}}}}],"externalArticle":false,"contentUrl":"https://www.topcoder.com/blog/single-round-match-737-editorials/"}},{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"79TYp0EEcKOnRD1FEVwIzp","type":"Entry","createdAt":"2020-04-20T12:42:13.318Z","updatedAt":"2026-02-16T23:07:19.359Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":46,"revision":3,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"article"}},"locale":"en-US"},"fields":{"title":"SRM 740","type":"Article","trackCategory":["Competitive Programming"],"contentCategory":[{"metadata":{"tags":[],"concepts":[]},"sys":{"space":{"sys":{"type":"Link","linkType":"Space","id":"piwi0eufbb2g"}},"id":"2oDccu9yr6fUp6Up8ZZDjm","type":"Entry","createdAt":"2019-12-12T09:29:01.248Z","updatedAt":"2020-05-06T16:45:33.209Z","environment":{"sys":{"id":"master","type":"Link","linkType":"Environment"}},"publishedVersion":39,"revision":6,"contentType":{"sys":{"type":"Link","linkType":"ContentType","id":"contentCategory"}},"locale":"en-US"},"fields":{"name":"SRM Editorials","trackParent":"Competitive Programming"}}],"tags":["Python","Java"],"creationDate":"2018-10-20T00:00:00.000Z","readTime":"30 min","content":"# Single Round Match 740 Editorials\n\nSRM 740 was held on Oct 20th at 12:00 UTC-4. The problems for the round were written and prepared by [misof](https://profiles.topcoder.com/misof). the tested by . Thanks to monsoon for editorials too.\n\n__Author__: Tomasz Idziaszek ([monsoon](https://profiles.topcoder.com/monsoon))\n\n## GetAccepted\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15138)\n\nSince every negation (no matter where it appears in the sentence) changes the meaning of the question to the opposite one, we only need to count the number of negations in the sentence. The odd number of negations results in the answer “True.”, and the even number of negations — in the answer “False.”\n\nWe can do it by splitting the sentence into words and count how many words “not” we get. See the following Python program:\n```\nclass GetAccepted:\ndef answer(self, question):\nnumber_of_nots = question.split().count(\"not\")\nif number_of_nots % 2 == 1: return \"False.\"\nelse: return \"True.\"\n```\n\nWe get even simpler solution, by observing that every negation increases the length of the question by 4. Thus we can base our answer on the parity of the length of the question divided by 4. See a sample Java program:\n```\npublic class GetAccepted {\npublic String answer(String question) {\nint number_of_nots = ( question.length() - \"Do you want to get accepted?\".length() ) / 4;\nif (number_of_nots % 2 == 1) return \"False.\"; else return \"True.\";\n}\n};\n```\n\n## LongJumpCompetition\n[Problem Details](https://archive.topcoder.com/ProblemStatement/pm/15136)\n\nIn this problem it is enough to simulate the process described in the statement. We maintain an ordered collection of contestants, and update the order after each round.\n\n```\nstruct Contestant {\nvector jumps;\nint bib;\nbool operator<(const Contestant& other) const {\n// Vectors are compared lexicographically\nif (jumps != other.jumps) return jumps > other.jumps;\nreturn bib < other.bib;\n}\nvoid add_jump(int len) {\njumps.push_back(len);\n// After adding a jump, sort jumps from the longest to the shortest\nsort(jumps.begin(), jumps.end(), greater());\n}\n};\nstruct LongJumpCompetition {\nvector recoverStandings(vector jumpLengths) {\nint n = jumpLengths.size() / 3;\nvector person(n);\n// Initialize an array of contestants with no jumps\nfor (int i=0; i order;\nfor(int i=0; i recoverStandings(vector jumpLengths) {\nint n = jumpLengths.size() / 3;\nvector, int> > person(n);\nfor(int i=0; i order;\nfor(int i=0; i