सबसे बाद में बढ़ रही है

Question

एक क्रम एक ऐसा अनुक्रम है जो शेष तत्वों के क्रम को बदले बिना कुछ तत्वों को हटाकर दूसरे अनुक्रम से प्राप्त किया जा सकता है। एक सख्ती से बढ़ती हुई परवर्तीता एक अनुवर्तीता है जिसमें प्रत्येक तत्व पूर्ववर्ती से बड़ा होता है।

किसी अनुक्रम की सबसे भारी बढ़ती कठोरता सबसे बड़ी तत्व राशि है जो सख्ती से बढ़ रही है।

अपनी पसंद की भाषा में एक कार्यक्रम या फ़ंक्शन को लागू करें जो गैर-नकारात्मक पूर्णांकों की दी गई सूची की भारी वृद्धि के तत्व को पाता है।

उदाहरण:

                    [] ->  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])

ध्यान दें कि आपको केवल सबसे बाद में बढ़ने वाले तत्व का योग देना है, न कि बाद में स्वयं को।

---

Asymptotically सबसे तेज कोड जीतता है, एक टाईब्रेकर के रूप में बाइट्स में छोटे कोड आकार के साथ।

Comments

अतुलनीय विषम दवाओं से निपटने के लिए आपकी क्या योजना है? संभावित रूप से दो महत्वपूर्ण चर हैं: अनुक्रम की लंबाई, और अनुक्रम में सबसे बड़े तत्व का आकार।

— पीटर टेलर

@PeterTaylor मैं asymptotic के रूप में अनुक्रम की लंबाई का चयन करता हूं। आपका समाधान पूर्णांक पर किसी भी बाध्य नहीं होना चाहिए, और विशेष रूप से लूप में शामिल संख्याओं के आकार के आधार पर मेमोरी को आवंटित या आवंटित नहीं करना चाहिए। यदि आपकी भाषा पसंद ने पूर्णांक को बाध्य कर दिया है, तो आपको माफ कर दिया जाता है, लेकिन आपको अपने समाधान में इस तथ्य का उपयोग नहीं करना चाहिए। क्या यह आपकी चिंताओं को पूरा करता है?

— orlp

आंशिक रूप से। यह अभी भी सैद्धांतिक रूप से संभव है (हालांकि संभवतः संभावना नहीं है) यह तथ्य कि दो अनबाउंड पूर्णांकों की तुलना उनके लॉग के आनुपातिक रूप से प्रासंगिक होती है, प्रासंगिक हो सकती है। आप पूर्णांकों पर O (1) समय मानने के लिए मूल संचालन (इसके अलावा, तुलना, शायद गुणा) की अनुमति देना चाह सकते हैं।

— पीटर टेलर

@PeterTaylor कम्प्यूटेशन का ट्रांसडाइकोटोमस मॉडल पर्याप्त विशिष्ट है?

— 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

पायथन, O (n लॉग एन)

मैंने इसे गोल्फ नहीं किया, क्योंकि मैं मुख्य रूप से चीजों के सबसे तेज़ कोड पक्ष पर प्रतिस्पर्धा कर रहा हूं। मेरा समाधान 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))

रनटाइम विश्लेषण:

प्रत्येक तत्व की अपनी प्रविष्टि स्थिति एक बार देखी गई है, एक बार डाली गई है, और संभवतः एक बार हटाए जाने के बाद, प्रत्येक लूप के लिए मानों की एक निरंतर संख्या के अलावा। जब से मैं उपयोग कर रहा हूँ में निर्मित द्विविभाजित पैकेज और blist पैकेज , उन कार्यों में से प्रत्येक के हैं O(log n)। इस प्रकार, समग्र रनटाइम है O(n log n)।

यह कार्यक्रम सबसे अच्छा संभव बढ़ती क्रमों की एक क्रमबद्ध सूची को बनाए रखने के द्वारा काम करता है, जो मूल्य और अनुक्रम राशि को समाप्त करने के टपल के रूप में प्रतिनिधित्व करता है। एक बढ़ती हुई संख्या उस सूची में होती है, यदि अभी तक कोई अन्य परिणाम नहीं मिले हैं, जिसका समापन मूल्य छोटा है और योग कम से कम उतना बड़ा है। ये अंतिम मूल्य के बढ़ते क्रम में बनाए हुए हैं, और आवश्यक रूप से राशि के बढ़ते क्रम में भी। यह संपत्ति प्रत्येक नव पाए जाने वाले उत्तराधिकारी के उत्तराधिकारी की जांच करके बनाई जाती है, और यदि उसका योग पर्याप्त बड़ा नहीं है, तो उसे हटा दिया जाता है, और तब तक दोहराता है जब तक कि एक बड़ी राशि के साथ अनुवर्ती, या सूची का अंत नहीं हो जाता।

Comments

दिलचस्प है, मेरा एक बहुत अलग समाधान ।

— 15

Answer 3

पायथन, O (n लॉग एन)

मैंने समस्या को तुच्छ बनाने के लिए एक सूचकांक परिवर्तन और एक निफ्टी डेटा संरचना (बाइनरी इंडेक्स ट्री) का उपयोग किया।

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. शुरू करते हैं। हम पेड़ को तत्वों के रैंक का उपयोग करते हुए अनुक्रमित करते हैं, न कि उनके सूचकांक को। इसका मतलब यह है कि यदि हम पेड़ को इंडेक्स 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}};।

— orlp

@orlp धन्यवाद! यह दिखाता है कि मैं c ++;) का उपयोग नहीं करता

— Tyilo

यहाँ एक बहुत छोटा संस्करण है (अभी भी सेट और वेक्टर की आवश्यकता है):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

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], निश्चित रूप से है?

— पीटर टेलर

@PeterTaylor Derp।

— orlp

यह उत्तर एक गंभीर दावेदार प्रतीत नहीं होता है।

— पिपरी