ভারীতম ক্রমবর্ধমান অনুচ্ছেদ

Question

একটি অনুবর্তন একটি ক্রম যা বাকী উপাদানগুলির ক্রম পরিবর্তন না করে কিছু উপাদান মুছে ফেলে অন্য ক্রম থেকে নেওয়া যেতে পারে der একটি কঠোরভাবে বর্ধমান অনুবর্তন একটি অনুচ্ছেদ যা প্রতিটি উপাদান পূর্ববর্তীটির চেয়ে বড় one

সিকোয়েন্সের সবচেয়ে ভারী ক্রমবর্ধমান সাবকোয়েন্সটি হ'ল কঠোরভাবে বর্ধমান অনুচ্ছেদ যা সবচেয়ে বড় উপাদানটির যোগফল।

আপনার পছন্দের ভাষায় এমন একটি প্রোগ্রাম বা ফাংশন প্রয়োগ করুন যা অ-নেতিবাচক পূর্ণসংখ্যার তালিকা প্রদত্ত তালিকার ভারীতম ক্রমবর্ধমান অনুচ্ছেদের মৌলিক যোগটি খুঁজে পায়।

উদাহরণ:

                    [] ->  0 ([])
                   [3] ->  3 ([3])
             [3, 2, 1] ->  3 ([3])
          [3, 2, 5, 6] -> 14 ([3, 5, 6])
       [9, 3, 2, 1, 4] ->  9 ([9])
       [3, 4, 1, 4, 1] ->  7 ([3, 4])
       [9, 1, 2, 3, 4] -> 10 ([1, 2, 3, 4])
       [1, 2, 4, 3, 4] -> 10 ([1, 2, 3, 4])
[9, 1, 2, 3, 4, 5, 10] -> 25 ([1, 2, 3, 4, 5, 10])
       [3, 2, 1, 2, 3] ->  6 ([1, 2, 3])

মনে রাখবেন যে আপনাকে কেবলমাত্র ভারীতম ক্রমবর্ধমান অনুচ্ছেদের মৌলিক যোগটি দিতে হবে, অনুচ্ছেদটি নিজেই নয়।

---

টাইব্রেকার হিসাবে বাইটে ছোট কোডের আকার সহ অ্যাসিম্পটোটিকভাবে দ্রুততম কোড জিততে পারে।

Comments

আপনি কীভাবে অতুলনীয় অ্যাসিম্পটোটিকগুলি মোকাবেলা করার পরিকল্পনা করছেন? সম্ভাব্য দুটি গুরুত্বপূর্ণ ভেরিয়েবল রয়েছে: অনুক্রমের দৈর্ঘ্য এবং অনুক্রমের বৃহত্তম উপাদানের আকার।

— পিটার টেলর

@ পিটারটেলর আমি অ্যাসিম্পটোটিক হিসাবে ক্রমটির দৈর্ঘ্য বেছে নিই। আপনার সমাধানটি অবশ্যই পূর্ণসংখ্যার উপর কোনও আবদ্ধ অনুমান করা উচিত নয় এবং বিশেষত জড়িত সংখ্যার আকারের ভিত্তিতে মেমরিটিকে লুপ বা বরাদ্দ করবেন না। আপনার ভাষা পছন্দটি যদি পূর্ণসংখ্যার সাথে সীমাবদ্ধ থাকে তবে আপনি ক্ষমা হয়ে গেছেন, তবে আপনার সমাধানে এই সত্যটি ব্যবহার করা উচিত নয়। এটি কি আপনার উদ্বেগগুলি মেটায়?

— orlp

আংশিকভাবে। এটি তাত্ত্বিকভাবে এখনও সম্ভব (যদিও সম্ভবত অসম্ভব) তবে যে দুটি আনবাউন্ডেড পূর্ণসংখ্যার তুলনা তাদের লগের সাথে আনুপাতিক আকারের গ্রহণ করে তা প্রাসঙ্গিক হতে পারে। আপনি পূর্ণসংখ্যার উপর ও (1) সময় হিসাবে ধরে নেওয়া বুনিয়াদি ক্রিয়াকলাপ (সংযোজন, তুলনা, গুণক) এর অনুমতি দিতে চাইতে পারেন।

— পিটার টেলর

@ পিটার টেইলর গণনার ট্রান্সডাইকোটমাস মডেল কি যথেষ্ট নির্দিষ্ট?

— orlp

যুক্তিযুক্ত মনে হয়।

— পিটার টেলর

Answer 1

জাভাস্ক্রিপ্ট (ES6) O(n log n)253 টি অক্ষর

function f(l){l=l.map((x,i)=>[x,i+1]).sort((a,b)=>a[0]-b[0]||1)
a=[0]
m=(x,y)=>x>a[y]?x:a[y]
for(t in l)a.push(0)
t|=0
for(j in l){for(i=(r=l[j])[1],x=0;i;i&=i-1)x=m(x,i)
x+=r[0]
for(i=r[1];i<t+2;i+=i&-i)a[i]=m(x,i)}for(i=t+1;i;i&=i-1)x=m(x,i)
return x}

এটি নির্দিষ্ট সাবকোয়েন্সির সর্বোচ্চটি খুঁজে পেতে ফেনউইক ট্রি (সর্বাধিক ফেনউইক ট্রি) ব্যবহার করে।

মূলত, ডেটাটাইপের অন্তর্নিহিত অ্যারেতে, প্রতিটি স্থান একই ক্রমে ইনপুট তালিকা থেকে কোনও উপাদানের সাথে মিলে যায়। ফেনউইক ট্রি সর্বত্র 0 দিয়ে শুরু করা হয়।

সবচেয়ে ছোট থেকে বড় পর্যন্ত, আমরা ইনপুট তালিকা থেকে একটি উপাদান নিয়ে থাকি এবং বামে সর্বাধিক উপাদান সন্ধান করি। তারা এই উপাদানগুলি যা পরের অংশে এটির আগে হতে পারে কারণ তারা ইনপুট অনুক্রমের বাম দিকে এবং ছোট, কারণ তারা গাছটিতে আগে প্রবেশ করেছিল।

সুতরাং আমরা যে সর্বাধিক খুঁজে পেয়েছি তা হ'ল সবচেয়ে ভারী ক্রম যা এই উপাদানটি পেতে পারে এবং তাই আমরা এটিতে এই উপাদানটির ওজন যুক্ত করে গাছটিতে সেট করি।

তারপরে, আমরা কেবল পুরো গাছের সর্বাধিক ফিরিয়ে আনি ফলাফল।

ফায়ার ফক্সে পরীক্ষিত

Answer 2

পাইথন, হে (এন লগ এন)

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

import bisect
import blist

def heaviest_subseq(in_list):
    best_subseq = blist.blist([(0, 0)])
    for new_elem in in_list:

        insert_loc = bisect.bisect_left(best_subseq, (new_elem, 0))

        best_pred_subseq_val = best_subseq[insert_loc - 1][1]

        new_subseq_val = new_elem + best_pred_subseq_val

        list_len = len(best_subseq)
        num_deleted = 0

        while (num_deleted + insert_loc < list_len
               and best_subseq[insert_loc][1] <= new_subseq_val):
            del best_subseq[insert_loc]
            num_deleted += 1

        best_subseq.insert(insert_loc, (new_elem, new_subseq_val))

    return max(val for key, val in best_subseq)

tests = [eval(line) for line in """[]
[3]
[3, 2, 1]
[3, 2, 5, 6]
[9, 3, 2, 1, 4]
[3, 4, 1, 4, 1]
[9, 1, 2, 3, 4]
[1, 2, 4, 3, 4]
[9, 1, 2, 3, 4, 5, 10]
[3, 2, 1, 2, 3]""".split('\n')]

for test in tests:
    print(test, heaviest_subseq(test))

রানটাইম বিশ্লেষণ:

প্রতিটি উপাদানটির সন্নিবেশের অবস্থানটি একবারে দেখানো হয়, একবার isোকানো হয় এবং লুপ প্রতি স্থির সংখ্যক মান সন্ধানের পাশাপাশি একবারে মুছে ফেলা হয়। যেহেতু আমি অন্তর্নির্মিত বাইসেক্ট প্যাকেজ এবং ব্লিস্ট প্যাকেজটি ব্যবহার করছি , সেই ক্রিয়াকলাপগুলির প্রতিটি হ'লO(log n) । সুতরাং, সামগ্রিক রানটাইম হয় O(n log n)।

প্রোগ্রামটি সম্ভাব্য সর্বোত্তম বর্ধমান অনুচ্ছেদগুলির একটি বাছাই করা তালিকা বজায় রেখে কাজ করে যা শেষের মান এবং ক্রম যোগফলের একটি টিপল হিসাবে উপস্থাপিত হয়। এখন পর্যন্ত অন্য কোনও উপসূত্র পাওয়া যায় নি যার শেষ মান কম এবং যোগফল কমপক্ষে বৃহত্তর হয় তবে সেই তালিকায় একটি বর্ধমান অনুবর্তনটি রয়েছে। এগুলি সমাপ্তি মূল্য ক্রমবর্ধমান ক্রম এবং বর্ধিত পরিমাণে যোগফল ক্রম বজায় রাখা হয়। এই বৈশিষ্ট্যটি প্রতিটি সদ্য পাওয়া উপসর্গের উত্তরসূরি পরীক্ষা করে এবং এর যোগফলটি যথেষ্ট পরিমাণে বড় না হলে এটি মুছে ফেলা এবং বৃহত্তর যোগফল সহ একটি অনুচ্ছেদটি পৌঁছানো বা তালিকার শেষে পৌঁছানো পর্যন্ত পুনরাবৃত্তি করেই এই সম্পত্তিটি রক্ষণাবেক্ষণ করা হয়।

Comments

আকর্ষণীয়, খনি থেকে খুব আলাদা সমাধান ।

— orlp

Answer 3

পাইথন, হে (এন লগ এন)

সমস্যাটিকে তুচ্ছ করতে আমি একটি সূচক রূপান্তর এবং একটি নিফ্টি ডেটা স্ট্রাকচার (বাইনারি ইনডেক্সড ট্রি) ব্যবহার করেছি।

def setmax(a, i, v):
    while i < len(a):
        a[i] = max(a[i], v)
        i |= i + 1

def getmax(a, i):
    r = 0
    while i > 0:
        r = max(r, a[i-1])
        i &= i - 1
    return r

def his(l):
    maxbit = [0] * len(l)
    rank = [0] * len(l)
    for i, j in enumerate(sorted(range(len(l)), key=lambda i: l[i])):
        rank[j] = i

    for i, x in enumerate(l):
        r = rank[i]
        s = getmax(maxbit, r)
        setmax(maxbit, r, x + s)

    return getmax(maxbit, len(l))

বাইনারি সূচিকৃত গাছ লগ (এন) এ দুটি ক্রিয়াকলাপ করতে পারে: সূচীতে i তে একটি মান বাড়ান এবং সর্বোচ্চ মান [0, i) পান। আমরা গাছের প্রতিটি মানকে 0 থেকে শুরু করি We এর অর্থ হ'ল আমরা যদি গাছটিকে সূচক i তে সূচক করি তবে সমস্ত উপাদান [0, i) i র‌্যাঙ্কযুক্ত একের চেয়ে ছোট উপাদান। এর অর্থ হ'ল আমরা [0, i) থেকে সর্বাধিক পাই, এতে বর্তমান মান যুক্ত করব এবং এটি i তে আপডেট করব। একমাত্র বিষয়টি হ'ল এটিতে এমন মানগুলি অন্তর্ভুক্ত করা হবে যা বর্তমান মানের থেকে কম, তবে ক্রম পরে আসবে। তবে যেহেতু আমরা বাম থেকে ডান অনুক্রমের মধ্য দিয়ে চলেছি এবং আমরা গাছের সমস্ত মানকে 0 তে সূচনা করেছি, সেগুলির মান 0 হবে এবং সুতরাং সর্বোচ্চটি প্রভাবিত করবে না।

Answer 4

পাইথন 2 - O(n^2)- 114 বাইট

def h(l):
 w=0;e=[]
 for i in l:
    s=0
    for j,b in e:
     if i>j:s=max(s,b)
    e.append((i,s+i));w=max(w,s+i)
 return w

Answer 5

সি ++ - O(n log n) - 261 বাইট

এখনই স্থির করা উচিত:

#include <set>
#include <vector>
int h(std::vector<int>l){int W=0,y;std::set<std::pair<int,int>>S{{-1,0}};for(w:l){auto a=S.lower_bound({w,-1}),b=a;y=prev(a)->second+w;for(;b!=S.end()&&b->second<=y;b++){}a!=b?S.erase(a,b):a;W=y>W?y:W;S.insert({w,y});}return W;}

Comments

auto S=set<pair<I,I>>();সহজ থেকে দীর্ঘ set<pair<I,I>> S;। #define I intচেয়ে দীর্ঘতর হয় using I=int;। দায়িত্ব অর্পণ করা কোনও প্রয়োজন নেই nকিছু, আপনি প্রতিস্থাপন করতে পারেন auto n=*prev(S.lower_bound({w,-1}));I y=n.secondসঙ্গে I y=prev(S.lower_bound({w,-1}))->second+w;।

— orlp

ওহ, এবং এর Sসূচনাটি খুব সংশ্লেষিত, আপনি কেবল সন্নিবেশ করানো এবং ব্যবহার করতে পারেন std::set<std::pair<int,int>>S{{-1,0}};।

— অরপাল

ধন্যবাদ! এটি দেখায় যে আমি সি ++ ব্যবহার করি না))

— টাইলো

এখানে একটি আরও সংক্ষিপ্ত সংস্করণ (এখনও সেট এবং ভেক্টর অন্তর্ভুক্ত প্রয়োজন):using namespace std;using I=int;I h(vector<I>l){I W=0;set<pair<I,I>>S{{-1,0}};for(I w:l){I y=prev(S.lower_bound({w,-1}))->second+w;W=max(W,y);S.insert({w,y});}return W;}

— orlp

ওহ এবং ডাম্প std::max, ব্যবহার W=y>W?y:W;।

— orlp 2'15

Answer 6

মতলব, ও ( এন 2 ^এন ), 90 বাইট

function m=f(x)
m=0;for k=dec2bin(1:2^numel(x)-1)'==49
m=max(m,all(diff(x(k))>0)*x*k);end

উদাহরণ:

>> f([])
ans =
     0
>> f([3])
ans =
     3
>> f([3, 2, 5, 6])
ans =
    14

Answer 7

পাইথন, ও (2 ^এন ), 91 বাইট

প্রতিযোগিতামূলক হওয়ার চেয়ে এটি মজাদার জন্য আরও বেশি। একটি আরকেন পুনরাবৃত্ত সমাধান:

h=lambda l,m=0:l and(h(l[1:],m)if l[0]<=m else max(h(l[1:],m),l[0]+h(l[1:],l[0])))or 0

Comments

max(m,l[0])দেওয়া not(l[0]<m)ঠিক আছে l[0], অবশ্যই?

— পিটার টেলর

@ পিটারটেলর ডের্প

— অরপাল

এই উত্তরটি কোনও গুরুতর প্রতিযোগী হিসাবে উপস্থিত হবে না।

— পিপ্পারি