বৃহত্তম অঙ্ক বিভাজক দ্বারা n

আমি স্ট্যাক ওভারফ্লোতে এই প্রশ্নটি জিজ্ঞাসা করেছি , তবে আমার কাছে মনে হয় এখানে আরও উপযুক্ত জায়গা।

এটি আলগোরিদিম কোর্সের ভূমিকা থেকে শুরু করে :

আপনি একটি অ্যারে আছে $a$ সঙ্গে $n$ ধনাত্মক পূর্ণসংখ্যা (অ্যারে সাজানো করা প্রয়োজন করে না অথবা অনন্য উপাদান)। একটি সুপারিশ $O(n)$ আলগোরিদিম উপাদানের বৃহত্তম সমষ্টি যে দিয়ে বিভাজ্য এটি $n$ ।

উদাহরণ: $a = [6, 1, 13, 4, 9, 8, 25], n = 7$ । উত্তর $56$ ( উপাদান সহ $6, 13, 4, 8, 25$ )

গতিশীল প্রোগ্রামিং ব্যবহার করে এবং সাথে সর্বাধিক পরিমাণ সঞ্চয় করে এটি এ খুঁজে পাওয়া তুলনামূলকভাবে সহজ $O(n^2)$ $0, 1, 2,..., n - 1$ ।

এছাড়াও, আমরা যদি উপাদানের একটি ধারাবাহিক অনুক্রমের দিকে মনোযোগ সীমাবদ্ধ রাখি তবে আংশিক অঙ্কের মডুলো সঞ্চয় করে সময়ে অনুকূল সেরকম সিকোয়েন্সটি খুঁজে পাওয়া সহজ : , প্রতিটি অবশিষ্ট জন্য মতো বৃহত্তম সূচক মনে রাখবেন $O(n)$ $n$ $S[i]=a[0]+a[1]+\dots + a[i]$ $r$ $j$ , এবং তারপরে প্রতিটি আপনি যেখানে হল সূচকটি । $S[j] \equiv r \pmod{n}$ $i$ $S[j]-S[i]$ $j$ $r=S[i] \bmod n$

তবে সাধারণ ক্ষেত্রে কি কোনও সময় সমাধান রয়েছে? কোন পরামর্শ প্রশংসা করা হবে! আমি লিনিয়ার বীজগণিতের সাথে মোকাবিলার জন্য এর কিছু আছে বলে আমি বিবেচনা করি তবে ঠিক কী তা আমি নিশ্চিত নই। $O(n)$

বিকল্পভাবে, সময়ে এটি করা যায়? $O(n \log n)$

— ব-দ্বীপ-টারমিনেটর
সূত্র

1. আপনি স্ট্যাক ওভারফ্লোতে ঠিক একই প্রশ্ন পোস্ট করেছেন। দয়া করে একাধিক সাইটে একই প্রশ্ন পোস্ট করবেন না । আমরা একাধিক এসই সাইটে ভাসমান একাধিক অনুলিপি চাই না। আপনি যদি কোনও গ্রহণযোগ্য উত্তর না পেয়ে থাকেন তবে আপনার প্রশ্নটি অন্য সাইটে স্থানান্তরের জন্য পতাকাঙ্কিত করা ঠিক আছে, তবে দয়া করে কেবল একই জিনিসটি অন্য কোথাও পুনরায় পোস্ট করবেন না। ২. আপনি যেখানে পাঠ্যপুস্তক বা কোর্সটি প্রকাশ করেছেন সেখানে কোনও রেফারেন্স / প্রশংসা / লিঙ্ক দিতে পারেন? আপনি কতটা নিশ্চিত যে একটি

সমাধান রয়েছে?

O (n)

$O(n)$

— DW

আপনার বিশ্ববিদ্যালয়ের চ্যালেঞ্জ কি এখনও খোলা আছে? কোর্সের লিঙ্কটি দেখা, সত্যিকারের প্রশ্ন এবং এটি সত্যই যদি

এবং এটি প্রস্তুত করা লোকেরা তাদের উত্তরটি ব্যাখ্যা / প্রকাশ করবে তবে তা দুর্দান্ত হবে।

O (n)

$O(n)$

— এভিল

এটি ও (এন 2) ও (এন 2) এ ডায়নামিক প্রোগ্রামিং ব্যবহার করে এবং 0,1,2, ..., n − 10,1,2, ..., n − 1 সহ সর্বাধিক পরিমাণ সঞ্চয় করে এটি অপেক্ষাকৃত সহজ। আপনি কি দয়া করে এটিকে কিছুটা ব্যাখ্যা করতে পারেন? আমি বুঝতে পারি এটি কীভাবে এন-স্কোয়ার্ড হবে যদি আমরা কেবল সংগত উপাদানগুলিকেই বিবেচনা করি তবে অ-তাত্পর্যপূর্ণ উপাদানগুলির সাথেও এটি ক্রম হিসাবে তাত্পর্যপূর্ণ হবে না?

— নীতিশ ইনপুটসুট অফহ্যাপিনেস

উত্তর:

এখানে কয়েকটি এলোমেলো ধারণা দেওয়া হল:

ডায়নামিক-প্রোগ্রামিং অ্যালগরিদম বৃহত্তম সংখ্যার পরিবর্তে একটি ক্ষুদ্রতর যোগ সন্ধান করতে উল্টানো যায়। আপনি কেবল এক জনের শূন্যের পরিবর্তে পুরো অ্যারের যোগফলের বাকী অংশের সন্ধান করতে পারেন। যদি আমরা উপাদানগুলিকে ক্রমবর্ধমান ক্রমে প্রসেস করি তবে এটি কখনও কখনও সম্পূর্ণ অ্যারে প্রক্রিয়াকরণের আগে গতিশীল অ্যালগরিদমকে শেষ হতে দেয়।

খরচ হবে যদি আমরা প্রক্রিয়াজাত উপাদান। আছে না একটি নিম্ন বাউন্ড কারণ আমরা সব উপাদান বাছাই করতে না থাকায় এই অ্যালগরিদম উপর। এটা শুধুমাত্র লাগে পেতে সময় ক্ষুদ্রতম উপাদান। $O(n k)$ $k$ $\Omega(n \log n)$ $O(n \log k)$ $k$
যদি আমরা বড় অঙ্কের সাথে সেটটির পরিবর্তে লার্জ আকারের সাথে সেটটির যত্ন নিয়ে থাকি তবে আমরা -তে সমস্যা সমাধানের জন্য দ্রুত-ফুরিয়ার-ট্রান্সফর্ম-ভিত্তিক বহুবর্ষীয় গুণটি ব্যবহার করতে সক্ষম হতে পারি সময়। ডোমেনের সীমা সীমাবদ্ধ হলে 3SUM এ যা হয়েছিল তার অনুরূপ to (দ্রষ্টব্য: ব্যবহার একটি বাইনারি অনুসন্ধান করতে বর্গ পুনরাবৃত্তি, অন্য আপনি পাবেন যেখানে $O(n (\log n)^2 (\log \log n))$ $O(n k (\log n) (\log \log n))$ $k$ বাদ দেওয়া উপাদানগুলির সংখ্যা))
যখন সংমিশ্রিত হয়, এবং প্রায় সমস্ত অবশিষ্টাংশগুলির মধ্যে একটির একাধিক হয় $n$ এর উপাদানগুলিরহয়, তখন সেই অবশিষ্টাংশের উপর ফোকাস করে উল্লেখযোগ্য সময় বাঁচানো যেতে পারে যা সেই ফ্যাক্টরের একাধিক নয়। $n$
যখন কোনও বাকী অংশ rখুব সাধারণ থাকে, বা সেখানে কেবলমাত্র কয়েকজন অবশিষ্ট রয়েছেন, 'আপনি যদি এখান থেকে শুরু করেন এবং পরবর্তী অগ্রযাত্রা চালিয়ে যান তবে পরবর্তী খোলার স্লটটি ট্র্যাক করে রাখুন r' তথ্যের ফলে জাম্প-ইন-ওপেন-স্পটগুলিতে প্রচুর স্ক্যান করা যায় সময়।
আপনি কেবলমাত্র পুনঃচঞ্চলতা ট্র্যাক করে এবং বিট মাস্কগুলি ব্যবহার করে (ফ্লিপড ডায়নামিক অ্যালগরিদমে) লগ ফ্যাক্টর শেভ করতে পারেন , তারপরে লক্ষ্যমাত্রার অবশিষ্টাংশে পৌঁছে একবার ব্যাকট্র্যাকিং করে।
গতিশীল প্রোগ্রামিং অ্যালগরিদম সমান্তরালভাবে চালিত হওয়ার জন্য খুব প্রশংসনীয়। প্রতিটি বাফার স্লটের জন্য একটি প্রসেসরের সাহায্যে আপনি নামতে পারেন । বিকল্পভাবে, প্রশস্ততা ব্যবহার করে এবং পুনরাবৃত্তি সমাগমের পরিবর্তে বিভাজন এবং একত্রিতকরণকে জয় করে, সার্কিট গভীরতার ব্যয়টি নিচে থেকে সমস্ত উপায়ে পেতে পারে । $O(n)$ $O(n^2)$ $O(\log^2 n)$
(Meta) I strongly suspect that the problem you were given is about contiguous sums. If you linked to the actual problem, it would be easy to verify that. Otherwise I'm very surprised by how difficult this problem is, given that it was assigned in a course called "Introduction to Algorithms". But maybe you covered a trick in class that makes it trivial.

— Craig Gidney
সূত্র

For point one. It's not written in the specifications of the problem, so you can't assume that. Also, the problem is not saying that you can't modify the array or create new ones, you can indeed. The only thing you need to do is find the numbers that summed together give you the largest sum that is divisible by

n

$n$ in

O (n)

$O(n)$ time complexity (usually it's assumed just the time complexity).

— nbro

@EvilJS The subset with the largest sum with remainder 0 is equal to the full set after removing the subset with the smallest sum with remainder congruent to the full set's sum. Looking for a smallest sum congruent to

r_{1}

$r_1$ is more convenient than looking for a largest sum congruent to

r_{2}

$r_2$ because it allows you to terminate as soon as you find a solution (when processing elements in increasing order) instead of having to continue.

— Craig Gidney

-1

My proposed algorithm goes as follows:

A sum is divisible by n if you only add summands which are multiples of n.

Before you start you create a hashmap with an int as key and a list of indices as value. You also create a resultlist containing indices.

You then loop over the array and add every index which mod n is zero to your result list. For every other index you do the following:

You subtract the value mod n of this index from n. This result is the key for your hashmap which stores indices for elements with the required value. Now, you add this index to the list in the hashmap and move on.

অ্যারের উপরে লুপিং শেষ করার পরে আপনি আউটপুট গণনা করুন। আপনি সূচককে নির্দেশিত মান অনুসারে হ্যাশম্যাপে প্রতিটি তালিকা বাছাই করে এটি করেন। এখন আপনি হ্যাশম্যাপের প্রতিটি জুটি এন পর্যন্ত যোগফল বিবেচনা করুন। সুতরাং যদি এন = 7 আপনি 3 এবং 4 এর জন্য হ্যাশম্যাপটি সন্ধান করেন তবে আপনি উভয়ের মধ্যে একটি এন্ট্রি পেয়ে গেলে আপনি দুটি বৃহত্তম মান গ্রহণ করেন তাদের তালিকা থেকে তাদের সরিয়ে দিন এবং আপনার ফলাফল তালিকায় যুক্ত করুন।

সর্বশেষ সুপারিশ: এখনও অ্যালগরিদম পরীক্ষা করেনি, একটি ব্রুট ফোর্স অ্যালগরিদম ব্যবহার করে এর বিরুদ্ধে একটি টেস্টকেস লিখুন।

— টোবিয়াস ওয়ারফল
সূত্র

Greedy, linear, not working. You consider only elements that are divisible by n and pairs divisible by n, what about triples and more? It does not guarantee maximal subset sum on trivial case. [2, 1, 8] -> maximal sum is 9, but your algorithm returns 3.

— Evil

@EvilJS what happened with your sub-

n^{2}

$n^2$ algorithm?

— delta-terminator

Thanks for pointing this mistake out to me. My idea on improvement would be to make a hashmap of stacks of lists which is ordered by increasing value and start accumulating only after completing a pass through the array.

— Tobias Würfl

You mean array of arrays, which will be sorted, and "hashmap" is % n? You still need to sort them, and if you have them sorted, taking minimal / maximal value is ok, but still there is inevitable part of actually choosing subset, which in the worst case does not benefit. Anyway if you have some improvements, maybe you could edit post?

— Evil

Yeah was quite a quick idea with the stacks. In fact you only need lists in the hashmap which you sort. I was not sure wether it is polite to edit my first answer. After all I made a mistake in my first attempt.

— Tobias Würfl

-2

use this DP method from (/programming/4487438/maximum-sum-of-non-consecutive-elements?rq=1):

Given an array A[0..n], let M(i) be the optimal solution using the elements with indices 0..i. Then M(-1) = 0 (used in the recurrence), M(0) = A[0], and M(i) = max(M(i - 1), M(i - 2) + A[i]) for i = 1, ..., n. M(n) is the solution we want. This is O(n). You can use another array to store which choice is made for each subproblem, and so recover the actual elements chosen.

Change recursion to M(i) = max(M(i - 1), M(i - 2) + A[i] ) such that is stored only if its divisible by N

— Pinhead
সূত্র

This doesn't work – I'll let you figure out why. (Hint: Try to run it on the constant 1 array.) Also, in this problem we do allow consecutive elements.

— Yuval Filmus

This is very good solution, just to totally different (and much easier) problem.

— Evil