ผลรวมเมทริกซ์ที่ไม่ทับซ้อนกัน

กำหนดkอาร์เรย์ที่มีความยาวnส่งออกผลรวมสูงสุดที่เป็นไปได้โดยใช้หนึ่งองค์ประกอบจากแต่ละอาร์เรย์โดยที่ไม่มีสององค์ประกอบมาจากดัชนีเดียวกัน รับประกันได้ว่า k <= n

อินพุต

รายการที่ไม่ว่างของอาร์เรย์ที่ไม่ว่างของจำนวนเต็ม

เอาท์พุต

จำนวนเต็มที่แทนยอดรวมสูงสุด

ตัวอย่าง

Input -> Output
[[1]] -> 1
[[1, 3], [1, 3]] -> 4
[[1, 4, 2], [5, 6, 1]] -> 9
[[-2, -21],[18, 2]] -> 0
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> 15
[[1, 2, 3, 4], [5, 4, 3, 2], [6, 2, 7, 1]] -> 16
[[-2, -1], [-1, -2]] -> -2

เยลลี่ , 10 6 ไบต์

ZŒ!ÆṭṀ

ลองออนไลน์!

(4 bytes ถูกบันทึกโดย @Dennis ซึ่งชี้ให้เห็นว่า Jelly มี builtin "ผลรวมของเส้นทแยงมุมหลัก" ฉันไม่ได้คาดหวังว่าจะมีหนึ่งในนั้นโซลูชันก่อนหน้านี้ใช้การดำเนินการโดยไม่ต้องใช้ builtin Æṭถูกกำหนดเป็น "trace" แต่การติดตามถูกกำหนดไว้สำหรับเมทริกซ์สี่เหลี่ยมเท่านั้น Jelly จะใช้การวางแนวทั่วไปกับเมทริกซ์สี่เหลี่ยมด้วยเช่นกัน)

การปรับปรุงคำตอบอื่น ๆ ส่วนใหญ่มาจากอัลกอริทึมที่ง่ายกว่า โปรแกรมนี้ถูกเขียนขึ้นใน Brachylog v2 ( {\p\iᶠ∋₎ᵐ+}ᶠot) แต่ Jelly มี builtins สำหรับบางส่วนของโปรแกรมที่ต้องสะกดใน Brachylog ดังนั้นสิ่งนี้จึงสั้นลง

คำอธิบาย

ZŒ!ÆṭṀ
Z            Swap rows and columns
 Œ!          Find all permutations of rows (thus columns of the original)
   Æṭ        {For each permutation}, take the sum of the main diagonal
     Ṁ       Take the maximum

มันควรจะชัดเจนว่าสำหรับวิธีการแก้ปัญหาใด ๆ เราสามารถเปลี่ยนคอลัมน์ของเมทริกซ์ดั้งเดิมให้วางสารละลายนั้นลงบนเส้นทแยงมุมหลัก ดังนั้นวิธีนี้ก็แค่ย้อนกลับไปหาการหาเส้นทแยงมุมหลักที่เป็นไปได้ทั้งหมด

โปรดทราบว่าการดำเนินการ "เปลี่ยนแปลงคอลัมน์" จะทำในลักษณะ "สลับสับเปลี่ยนแถว" โดยไม่รบกวนการแปลงกลับ ส่วนที่เหลือของอัลกอริทึมนั้นมีความสมมาตรเกี่ยวกับเส้นทแยงมุมหลักดังนั้นเราไม่จำเป็นต้องยกเลิกการสลับตำแหน่งและสามารถบันทึกไบต์ได้

J , 28 ไบต์

>./@({.+1$:@|:\.|:@}.)@[^:]#

ลองออนไลน์!

 >./ @  (   {.   +         1 $:@|:\. |:@}.       )       @[^:] #
(max of (1st row + recursive call on each "minor")) or count of arg if 0

นี่คือการเรียกแบบเรียกซ้ำโดยทำ$:หน้าที่แทนฟังก์ชันที่ไม่ระบุตัวตนที่ใหญ่ที่สุด เราโชคดีใน J ที่มีดั้งเดิมx u\. yซึ่งนำuไปใช้กับ "outfixes" ต่อเนื่องที่yได้รับจากการระงับ infixes ต่อเนื่องของความยาวxของรายการในy; ที่นี่เราต้องการบีบอัดคอลัมน์ที่ต่อเนื่องเพื่อรับ "ผู้เยาว์" ดังนั้นเราจึงเปลี่ยน|:แถวที่ต่ำกว่า (หรือส่วนท้าย}.) ของyจากนั้นจึงทำการหักล้างส่วนท้ายของการเปลี่ยนแปลง

Python 3 , 94 90 89 84 80 ไบต์

^{-4 ไบต์ขอบคุณxnor (การใช้ชุดแทนรายการ)!}

f=lambda x,y={-1}:x>[]and max(e+f(x[1:],y|{i})for(i,e)in enumerate(x[0])if{i}-y)

ลองออนไลน์!

Husk , 12 11 9 ไบต์

▲mȯΣ►L∂PT

ลองออนไลน์!

ขอบคุณBMOสำหรับการแนะนำพอร์ตของคำตอบ ais523และการประหยัดขนาด 2 ไบต์ซึ่งฉันสามารถปรับปรุงเพิ่มเติมได้

โซลูชันก่อนหน้า (14 ไบต์)

▲moΣz!¹fS=uΠmŀ

ลองออนไลน์!

ฉันไม่สามารถสร้างชุดทดสอบได้เนื่องจากคำตอบนี้ใช้คำสั่งอาร์กิวเมนต์บรรทัดคำสั่งแรกอย่างชัดเจน แต่ Husk ไม่ได้ใช้ STDIN เลยดังนั้นฉันจึงรวมกรณีทดสอบทั้งหมดไว้ที่นั่นดังนั้นคุณสามารถคัดลอกวางในฟิลด์อาร์กิวเมนต์เพื่อตรวจสอบได้ นอกจากนี้โปรดทราบว่าอาร์เรย์ใน Husk อาจไม่มีช่องว่างระหว่างองค์ประกอบในขณะที่กำลังป้อนข้อมูล

มันทำงานอย่างไร?

การวิเคราะห์รหัส

▲moΣz!¹fS=uΠmŀ     Full program. Takes a 2D list from CLA 1 and outputs to STDOUT.
            mŀ     Length range of each list. 
           Π       Cartesian product.
       fS=u        Discard those combinations which have at least 1 non-unique element.
 mo                Map over the combinations with the following predicate:
    z!¹            Zip the 2D list input with the current combination and index accordingly.
   Σ               Sum the resulting elements.
▲                  Finally, pick the maximum.

ตัวอย่าง

เราต้องเลือกหนึ่งดัชนีจากแต่ละดัชนีโดยที่ไม่มีดัชนีสองตัวที่ตรงกัน ดังนั้นเราจึงสร้างช่วงความยาวของแถวและเก็บไว้โดยไม่ซ้ำกันทำให้ได้ชุดค่าผสมต่อไปนี้ (ชุดค่าผสมแต่ละชุดเป็นคอลัมน์แทนที่จะเป็นแถวเพื่อประหยัดพื้นที่):

จากนั้นโปรแกรมจะจัดทำดัชนีในรายการอินพุตพร้อมกับแต่ละองค์ประกอบของชุดค่าผสมซึ่งจะคืนค่า:

$9$

JavaScript (ES6),  74  71 ไบต์

ขอบคุณ @tsh สำหรับการระบุ 2 ไบต์ที่ไร้ประโยชน์ที่ใช้เพื่อแก้ไขข้อผิดพลาดที่
บันทึกไว้ 3 ไบต์ขอบคุณ @tsh

f=([a,...r],k,i=1)=>a?Math.max(...a.map(n=>k&(i+=i)?-1/0:n+f(r,k|i))):0

ลองออนไลน์!

เยลลี่ , 13 12 ไบต์

ẈŒpQƑƇị"€¹§Ṁ

ลองออนไลน์!

รุ่นสำรอง 11 ไบต์

ZLœ!Lị"€¹§Ṁ

สิ่งนี้ใช้œ!บิวด์อินที่เพิ่มใหม่ซึ่งสร้างการเรียงสับเปลี่ยนทั้งหมดตามความยาวที่กำหนด

ลองออนไลน์!

มันทำงานอย่างไร

ẈŒpQƑƇị"€¹§Ṁ  Main link. Argument: M (matrix)

Ẉ             Widths; compute the length of each row.
              For an n×m matrix, this yields an array m copies of n.
 Œp           Cartesian product; promote each n to [1, ..., n], then form all arrays
              that pick one k out of all m copies of [1, ..., n].
   QƑƇ        Comb by fixed unique; keep only arrays that do not change by
              deduplicating their entries.
         ¹    Identity; yield M.
      ị"€     For each of the arrays of unique elements, use its m entries to index
              into the m rows of M.
          §   Take the sums of all resulting vectors.
           Ṁ  Take the maximum.

Haskell , 65 ไบต์

f(u:v)=maximum[e+f(take i<>drop(i+1)<$>v)|(i,e)<-zip[0..]u]
f _=0

ลองออนไลน์!

คำอธิบาย & Ungolfed

ฟังก์ชั่นใช้เวลารายการและเอาองค์ประกอบที่ตำแหน่งtake i<>drop(i+1)i

ฟังก์ชั่นfรับแต่ละองค์ประกอบeที่เป็นไปได้ที่ตำแหน่งiลบองค์ประกอบที่ตำแหน่งiจากองค์ประกอบที่เหลือและเพิ่มeการคำนวณซ้ำที่เหมาะสมที่สุด:

f(u:v)=maximum[e+f(removeElementAt i<$>v)|(i,e)<-zip[0..]u]

และกรณีฐานสำหรับรายการที่ว่างเปล่าเป็นเพียง0:

f _=0

Brachylogขนาด 18 ไบต์

{hl⟦kp;?z₀∋₍ᵐ+}ᶠot

ลองออนไลน์!

คำอธิบาย

                ot      The output is the biggest result of…
{             }ᶠ        …finding all outputs to the following predicate:
 hl⟦k                     Construct the range [0, …, n-1]
     p                    Take a permutation of that range
      ;?z₀                Zip that permutation with the Input, stopping when all elements of
                            the input are used (important because the range is possibly
                            bigger than the length of the input)
          ∋₍ᵐ             In each element of the zip, take the head'th element of the tail
             +            Sum the result

Perl 6 , 50 49 ไบต์

{max map *.map({.[$++]}).sum,permutations [Z] $_}

ลองออนไลน์!

ค่อนข้างสั้นแม้จะมีpermutationsสายยาว นี่คือบล็อกรหัสที่ไม่ระบุชื่อที่ใช้รายการของรายการและส่งกลับตัวเลข

คำอธิบาย:

{                                               } # Anonymous code block
 max                                              # Finds the maximum
                             permutations         # Of all permutations
                                          [Z] $_  # Of the transposed input
     map                                          # When mapped to
                        .sum # The sum of
         *.map({.[$++]})     # The diagonal of the matrix

K (oK) , 40, 32, 28, 19 ไบต์

-13 ไบต์ขอบคุณ ngn!

{|/+/(prm'x)@''!#x}

ลองออนไลน์!

วิธีแก้ปัญหาเบื้องต้น:

{|/+/'x./:/:(*t),'/:t:{x~?x}#+!(#x)##*x}

ลองออนไลน์!

หมายเหตุ: ใช้ไม่ได้กับกรณีทดสอบครั้งแรก [[1]]

คำอธิบาย:

{ } - ฟังก์ชันพร้อมอาร์กิวเมนต์ x

                                   #     - creata a list
                               (#x)      - with length number of rows of x
                                    #*x  - of the length of the first row
                              !          - odometer (ranged permutations)
                             +           - transpose
                            #            - filter out the rows
                      {x~?x}             - that have duplicates
                    t:                   - save it to t 
                ,'/:                     - pair up each number in each row with
            (*t)                         - a number from the first row
      x./:/:                             - index x with each of the above
   +/'                                   - find the sum of each row
 |/                                      - reduce by max

Haskell , 65 ไบต์

([]%)
p%(h:t)=maximum[x+(i:p)%t|(i,x)<-zip[0..]h,all(/=i)p]
p%_=0

ลองออนไลน์!

71 ไบต์

f m=maximum[sum b|(a,b)<-unzip<$>mapM(zip[0..])m,[x|x<-a,y<-a,x==y]==a]

ลองออนไลน์!

การ[x|x<-a,y<-a,x==y]==aตรวจสอบว่าองค์ประกอบของaมีความแตกต่าง สิ่งนี้ใช้ตัวละครจำนวนมาก แต่ฉันไม่เห็นวิธีที่สั้นกว่านี้

Pyth, 15 12 ไบต์

eSms@VQd.plh

ลองออนไลน์ได้ที่นี่

eSms@VQd.plhQ   Implicit: Q=eval(input())
                Trailing Q inferred
          lhQ   Length of first element of Q
        .p      Generate all permutaions of 0 to the above
  m             Map the elements of the above, as d, using:
    @VQd          Vectorised index into Q using d
                    For i in [0-length(Q)), yield Q[i][d[i]]
   s              Take the sum of the above
 S              Sort the result of the map
e               Take the last element of the above, implicit print

แก้ไข: บันทึก 3 ครั้งด้วยความอนุเคราะห์ของ issacg

05AB1E , 18 13 ไบต์

нgLœε‚øε`è]OZ

ฉันมีความรู้สึกว่ามันมากเกินไปนาน แต่ผมไม่แน่ใจว่าวิธีการทำจัดทำดัชนี vectorized ไบต์ได้อย่างมีประสิทธิภาพใน 05AB1E ..และฉันก็แน่นอนขวาว่ามันยาวเกินไป .. -5 ไบต์ขอบคุณที่@Emigna

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

н                # Take the first inner list (of the implicit input list of lists)
 g               # Pop and take its length
  L              # Create a list in the range [1, inner-length]
   œ             # Create each possible permutation of this range-list
    ε            # Map each permutation to:
     ‚           #  Pair it with the (implicit) input
      ø          #  Transpose; swap rows/columns
       ε         #  Map each to:
        `        #   Push both to the stack
         è       #   Index the permutation-nr into the inner list of the input
    ]            # Close both maps
     O           # Take the sum of each inner list
      à          # Pop and push the maximum (and output implicitly)

ตัวอย่างการเรียกใช้:

• การป้อนข้อมูล: [[1,4,2],[5,6,1]]
• หลังจากขั้นตอนที่ 1 ( нgL):[1,2,3]
• หลังจากขั้นตอนที่ 2 ( œ):[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
• หลังจากขั้นตอนที่ 3 ( ε‚):[[[[1,4,2],[5,6,1]],[1,2,3]],[[[1,4,2],[5,6,1]],[1,3,2]],[[[1,4,2],[5,6,1]],[2,1,3]],[[[1,4,2],[5,6,1]],[2,3,1]],[[[1,4,2],[5,6,1]],[3,1,2]],[[[1,4,2],[5,6,1]],[3,2,1]]]
• หลังจากขั้นตอนที่ 4 ( ø):[[[[1,4,2],1],[[5,6,1],2]],[[[1,4,2],1],[[5,6,1],3]],[[[1,4,2],2],[[5,6,1],1]],[[[1,4,2],2],[[5,6,1],3]],[[[1,4,2],3],[[5,6,1],1]],[[[1,4,2],3],[[5,6,1],2]]]
• หลังจากขั้นตอนที่ 5 ( ε`è]): [[4,1],[4,5],[2,6],[2,5],[1,6],[1,1]](หมายเหตุ: 05AB1E ได้รับการจัดทำดัชนี 0 (โดยมีการขึ้นบรรทัดใหม่อัตโนมัติ) ดังนั้นการจัดทำดัชนี3เป็น[5,6,1]ผลลัพธ์จะเป็น5)
• หลังจากขั้นตอนที่ 6 ( O):[5,9,8,7,7,2]
• เอาท์พุท / หลังขั้นตอนที่ 7 ( à):9

Haskell, 84 ไบต์

import Data.List
h l=maximum[sum$snd<$>r|r<-mapM id$zip[1..]<$>l,(==)=<<nub$fst<$>r]

ลองออนไลน์!

Ruby , 74 72 69 ไบต์

->a{[*0...a[0].size].permutation.map{|x|a.zip(x).sum{|y,z|y[z]}}.max}

ลองออนไลน์!

05AB1E , 7 ไบต์

øœ€Å\Oà

คำตอบ Jelly CWของพอร์ตของ@ ais523 ดังนั้นอย่าลืมโหวตขึ้นเช่นกัน!

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ø          # Transpose the (implicit) input; swapping row/columns
 œ         # Get all permutations
  ہ\      # Take the main diagonal of each
     O     # Sum each
      à    # Pop and push the maximum (which is output implicitly)