Advertisement
G_Burlakova

SubsetSums

Mar 31st, 2014
184
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 27.44 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. class SubsetSums
  8. {
  9.     static void Main(string[] args)
  10.     {
  11.         //80 tochki
  12.         long s = long.Parse(Console.ReadLine());
  13.         int n = int.Parse(Console.ReadLine());
  14.         long[] numbers = new long[n];
  15.         long sum = 0;
  16.         int subsetsCount = 0;
  17.         for (int i = 0; i < n; i++)
  18.         {
  19.             numbers[i] = long.Parse(Console.ReadLine());
  20.         }
  21.         if (n >= 1)
  22.         {
  23.             for (int i = 0; i < n; i++)
  24.             {
  25.                 sum = numbers[i];
  26.                 if (sum == s)
  27.                 {
  28.                     subsetsCount++;
  29.                 }
  30.             }
  31.         }
  32.         if (n >= 2)
  33.         {
  34.             for (int i = 0; i < n; i++)
  35.             {
  36.                 for (int j = i + 1; j < n; j++)
  37.                 {
  38.                     sum = numbers[i] + numbers[j];
  39.                     if (sum == s)
  40.                     {
  41.                         subsetsCount++;
  42.                     }
  43.                 }
  44.             }
  45.         }
  46.         else
  47.         {
  48.             Console.WriteLine(subsetsCount);
  49.             return;
  50.         }
  51.         if (n >= 3)
  52.         {
  53.             for (int i = 0; i < n; i++)
  54.             {
  55.                 for (int j = i + 1; j < n; j++)
  56.                 {
  57.                     for (int k = j + 1; k < n; k++)
  58.                     {
  59.                         sum = numbers[i] + numbers[j] + numbers[k];
  60.                         if (sum == s)
  61.                         {
  62.                             subsetsCount++;
  63.                         }
  64.                     }
  65.                    
  66.                 }
  67.             }
  68.         }
  69.         else
  70.         {
  71.             Console.WriteLine(subsetsCount);
  72.             return;
  73.         }
  74.         if (n >= 4)
  75.         {
  76.             for (int i = 0; i < n; i++)
  77.             {
  78.                 for (int j = i + 1; j < n; j++)
  79.                 {
  80.                     for (int k = j + 1; k < n; k++)
  81.                     {
  82.                         for (int l = k + 1; l < n; l++)
  83.                         {
  84.                             sum = numbers[i] + numbers[j] + numbers[k] + numbers[l];
  85.                             if (sum == s)
  86.                             {
  87.                                 subsetsCount++;
  88.                             }
  89.                         }
  90.                        
  91.                     }
  92.                 }
  93.             }
  94.         }
  95.         else
  96.         {
  97.             Console.WriteLine(subsetsCount);
  98.             return;
  99.         }
  100.         if (n >= 5)
  101.         {
  102.             for (int i = 0; i < n; i++)
  103.             {
  104.                 for (int j = i + 1; j < n; j++)
  105.                 {
  106.                     for (int k = j + 1; k < n; k++)
  107.                     {
  108.                         for (int l = k + 1; l < n; l++)
  109.                         {
  110.                             for (int m = l + 1; m < n; m++)
  111.                             {
  112.                                 sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m];
  113.                                 if (sum == s)
  114.                                 {
  115.                                     subsetsCount++;
  116.                                 }
  117.                             }  
  118.                         }
  119.  
  120.                     }
  121.                 }
  122.             }
  123.         }
  124.         else
  125.         {
  126.             Console.WriteLine(subsetsCount);
  127.             return;
  128.         }
  129.         if (n >= 6)
  130.         {
  131.             for (int i = 0; i < n; i++)
  132.             {
  133.                 for (int j = i + 1; j < n; j++)
  134.                 {
  135.                     for (int k = j + 1; k < n; k++)
  136.                     {
  137.                         for (int l = k + 1; l < n; l++)
  138.                         {
  139.                             for (int m = l + 1; m < n; m++)
  140.                             {
  141.                                 for (int p = m + 1; p < n; p++)
  142.                                 {
  143.                                     sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p];
  144.                                     if (sum == s)
  145.                                     {
  146.                                         subsetsCount++;
  147.                                     }
  148.                                 }
  149.                                
  150.                             }
  151.                         }
  152.  
  153.                     }
  154.                 }
  155.             }
  156.         }
  157.         else
  158.         {
  159.             Console.WriteLine(subsetsCount);
  160.             return;
  161.         }
  162.         if (n >= 7)
  163.         {
  164.             for (int i = 0; i < n; i++)
  165.             {
  166.                 for (int j = i + 1; j < n; j++)
  167.                 {
  168.                     for (int k = j + 1; k < n; k++)
  169.                     {
  170.                         for (int l = k + 1; l < n; l++)
  171.                         {
  172.                             for (int m = l + 1; m < n; m++)
  173.                             {
  174.                                 for (int p = m + 1; p < n; p++)
  175.                                 {
  176.                                     for (int q = p + 1; q < n; q++)
  177.                                     {
  178.                                         sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q];
  179.                                         if (sum == s)
  180.                                         {
  181.                                             subsetsCount++;
  182.                                         }
  183.                                     }
  184.                                    
  185.                                 }
  186.  
  187.                             }
  188.                         }
  189.  
  190.                     }
  191.                 }
  192.             }
  193.         }
  194.         else
  195.         {
  196.             Console.WriteLine(subsetsCount);
  197.             return;
  198.         }
  199.         if (n >= 8)
  200.         {
  201.             for (int i = 0; i < n; i++)
  202.             {
  203.                 for (int j = i + 1; j < n; j++)
  204.                 {
  205.                     for (int k = j + 1; k < n; k++)
  206.                     {
  207.                         for (int l = k + 1; l < n; l++)
  208.                         {
  209.                             for (int m = l + 1; m < n; m++)
  210.                             {
  211.                                 for (int p = m + 1; p < n; p++)
  212.                                 {
  213.                                     for (int q = p + 1; q < n; q++)
  214.                                     {
  215.                                         for (int r = q + 1; r < n; r++)
  216.                                         {
  217.                                             sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r];
  218.                                             if (sum == s)
  219.                                             {
  220.                                                 subsetsCount++;
  221.                                             }
  222.                                         }
  223.                                        
  224.                                     }
  225.  
  226.                                 }
  227.  
  228.                             }
  229.                         }
  230.  
  231.                     }
  232.                 }
  233.             }
  234.         }
  235.         else
  236.         {
  237.             Console.WriteLine(subsetsCount);
  238.             return;
  239.         }
  240.         if (n >= 9)
  241.         {
  242.             for (int i = 0; i < n; i++)
  243.             {
  244.                 for (int j = i + 1; j < n; j++)
  245.                 {
  246.                     for (int k = j + 1; k < n; k++)
  247.                     {
  248.                         for (int l = k + 1; l < n; l++)
  249.                         {
  250.                             for (int m = l + 1; m < n; m++)
  251.                             {
  252.                                 for (int p = m + 1; p < n; p++)
  253.                                 {
  254.                                     for (int q = p + 1; q < n; q++)
  255.                                     {
  256.                                         for (int r = q + 1; r < n; r++)
  257.                                         {
  258.                                             for (int x = r + 1; x < n; x++)
  259.                                             {
  260.                                                 sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x];
  261.                                                 if (sum == s)
  262.                                                 {
  263.                                                     subsetsCount++;
  264.                                                 }
  265.                                             }
  266.                                            
  267.                                         }
  268.  
  269.                                     }
  270.  
  271.                                 }
  272.  
  273.                             }
  274.                         }
  275.  
  276.                     }
  277.                 }
  278.             }
  279.         }
  280.         else
  281.         {
  282.             Console.WriteLine(subsetsCount);
  283.             return;
  284.         }
  285.         if (n >= 10)
  286.         {
  287.             for (int i = 0; i < n; i++)
  288.             {
  289.                 for (int j = i + 1; j < n; j++)
  290.                 {
  291.                     for (int k = j + 1; k < n; k++)
  292.                     {
  293.                         for (int l = k + 1; l < n; l++)
  294.                         {
  295.                             for (int m = l + 1; m < n; m++)
  296.                             {
  297.                                 for (int p = m + 1; p < n; p++)
  298.                                 {
  299.                                     for (int q = p + 1; q < n; q++)
  300.                                     {
  301.                                         for (int r = q + 1; r < n; r++)
  302.                                         {
  303.                                             for (int x = r + 1; x < n; x++)
  304.                                             {
  305.                                                 for (int y = r + 1; y < n; y++)
  306.                                                 {
  307.                                                     sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y];
  308.                                                     if (sum == s)
  309.                                                     {
  310.                                                         subsetsCount++;
  311.                                                     }
  312.                                                 }
  313.                                                
  314.                                             }
  315.  
  316.                                         }
  317.  
  318.                                     }
  319.  
  320.                                 }
  321.  
  322.                             }
  323.                         }
  324.  
  325.                     }
  326.                 }
  327.             }
  328.         }
  329.         else
  330.         {
  331.             Console.WriteLine(subsetsCount);
  332.             return;
  333.         }
  334.         if (n >= 11)
  335.         {
  336.             for (int i = 0; i < n; i++)
  337.             {
  338.                 for (int j = i + 1; j < n; j++)
  339.                 {
  340.                     for (int k = j + 1; k < n; k++)
  341.                     {
  342.                         for (int l = k + 1; l < n; l++)
  343.                         {
  344.                             for (int m = l + 1; m < n; m++)
  345.                             {
  346.                                 for (int p = m + 1; p < n; p++)
  347.                                 {
  348.                                     for (int q = p + 1; q < n; q++)
  349.                                     {
  350.                                         for (int r = q + 1; r < n; r++)
  351.                                         {
  352.                                             for (int x = r + 1; x < n; x++)
  353.                                             {
  354.                                                 for (int y = r + 1; y < n; y++)
  355.                                                 {
  356.                                                     for (int z = y + 1; z < n; z++)
  357.                                                     {
  358.                                                         sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y] + numbers[z];
  359.                                                         if (sum == s)
  360.                                                         {
  361.                                                             subsetsCount++;
  362.                                                         }
  363.                                                     }
  364.                                                    
  365.                                                 }
  366.  
  367.                                             }
  368.  
  369.                                         }
  370.  
  371.                                     }
  372.  
  373.                                 }
  374.  
  375.                             }
  376.                         }
  377.  
  378.                     }
  379.                 }
  380.             }
  381.         }
  382.         else
  383.         {
  384.             Console.WriteLine(subsetsCount);
  385.             return;
  386.         }
  387.         if (n >= 12)
  388.         {
  389.             for (int i = 0; i < n; i++)
  390.             {
  391.                 for (int j = i + 1; j < n; j++)
  392.                 {
  393.                     for (int k = j + 1; k < n; k++)
  394.                     {
  395.                         for (int l = k + 1; l < n; l++)
  396.                         {
  397.                             for (int m = l + 1; m < n; m++)
  398.                             {
  399.                                 for (int p = m + 1; p < n; p++)
  400.                                 {
  401.                                     for (int q = p + 1; q < n; q++)
  402.                                     {
  403.                                         for (int r = q + 1; r < n; r++)
  404.                                         {
  405.                                             for (int x = r + 1; x < n; x++)
  406.                                             {
  407.                                                 for (int y = r + 1; y < n; y++)
  408.                                                 {
  409.                                                     for (int z = y + 1; z < n; z++)
  410.                                                     {
  411.                                                         for (int a = z + 1; a < n; a++)
  412.                                                         {
  413.                                                             sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y] + numbers[z] + numbers[a];
  414.                                                             if (sum == s)
  415.                                                             {
  416.                                                                 subsetsCount++;
  417.                                                             }
  418.                                                         }
  419.                                                        
  420.                                                     }
  421.  
  422.                                                 }
  423.  
  424.                                             }
  425.  
  426.                                         }
  427.  
  428.                                     }
  429.  
  430.                                 }
  431.  
  432.                             }
  433.                         }
  434.  
  435.                     }
  436.                 }
  437.             }
  438.         }
  439.         else
  440.         {
  441.             Console.WriteLine(subsetsCount);
  442.             return;
  443.         }
  444.         if (n >= 13)
  445.         {
  446.             for (int i = 0; i < n; i++)
  447.             {
  448.                 for (int j = i + 1; j < n; j++)
  449.                 {
  450.                     for (int k = j + 1; k < n; k++)
  451.                     {
  452.                         for (int l = k + 1; l < n; l++)
  453.                         {
  454.                             for (int m = l + 1; m < n; m++)
  455.                             {
  456.                                 for (int p = m + 1; p < n; p++)
  457.                                 {
  458.                                     for (int q = p + 1; q < n; q++)
  459.                                     {
  460.                                         for (int r = q + 1; r < n; r++)
  461.                                         {
  462.                                             for (int x = r + 1; x < n; x++)
  463.                                             {
  464.                                                 for (int y = r + 1; y < n; y++)
  465.                                                 {
  466.                                                     for (int z = y + 1; z < n; z++)
  467.                                                     {
  468.                                                         for (int a = z + 1; a < n; a++)
  469.                                                         {
  470.                                                             for (int b = a + 1; b < n; b++)
  471.                                                             {
  472.                                                                 sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y] + numbers[z] + numbers[a] + numbers[b];
  473.                                                                 if (sum == s)
  474.                                                                 {
  475.                                                                     subsetsCount++;
  476.                                                                 }
  477.                                                             }
  478.                                                            
  479.                                                         }
  480.  
  481.                                                     }
  482.  
  483.                                                 }
  484.  
  485.                                             }
  486.  
  487.                                         }
  488.  
  489.                                     }
  490.  
  491.                                 }
  492.  
  493.                             }
  494.                         }
  495.  
  496.                     }
  497.                 }
  498.             }
  499.         }
  500.         else
  501.         {
  502.             Console.WriteLine(subsetsCount);
  503.             return;
  504.         }
  505.         if (n >= 14)
  506.         {
  507.             for (int i = 0; i < n; i++)
  508.             {
  509.                 for (int j = i + 1; j < n; j++)
  510.                 {
  511.                     for (int k = j + 1; k < n; k++)
  512.                     {
  513.                         for (int l = k + 1; l < n; l++)
  514.                         {
  515.                             for (int m = l + 1; m < n; m++)
  516.                             {
  517.                                 for (int p = m + 1; p < n; p++)
  518.                                 {
  519.                                     for (int q = p + 1; q < n; q++)
  520.                                     {
  521.                                         for (int r = q + 1; r < n; r++)
  522.                                         {
  523.                                             for (int x = r + 1; x < n; x++)
  524.                                             {
  525.                                                 for (int y = r + 1; y < n; y++)
  526.                                                 {
  527.                                                     for (int z = y + 1; z < n; z++)
  528.                                                     {
  529.                                                         for (int a = z + 1; a < n; a++)
  530.                                                         {
  531.                                                             for (int b = a + 1; b < n; b++)
  532.                                                             {
  533.                                                                 for (int c = b + 1; c < n; c++)
  534.                                                                 {
  535.                                                                     sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y] + numbers[z] + numbers[a] + numbers[b] + numbers[c];
  536.                                                                     if (sum == s)
  537.                                                                     {
  538.                                                                         subsetsCount++;
  539.                                                                     }
  540.                                                                 }
  541.                                                                
  542.                                                             }
  543.  
  544.                                                         }
  545.  
  546.                                                     }
  547.  
  548.                                                 }
  549.  
  550.                                             }
  551.  
  552.                                         }
  553.  
  554.                                     }
  555.  
  556.                                 }
  557.  
  558.                             }
  559.                         }
  560.  
  561.                     }
  562.                 }
  563.             }
  564.         }
  565.         else
  566.         {
  567.             Console.WriteLine(subsetsCount);
  568.             return;
  569.         }
  570.         if (n >= 15)
  571.         {
  572.             for (int i = 0; i < n; i++)
  573.             {
  574.                 for (int j = i + 1; j < n; j++)
  575.                 {
  576.                     for (int k = j + 1; k < n; k++)
  577.                     {
  578.                         for (int l = k + 1; l < n; l++)
  579.                         {
  580.                             for (int m = l + 1; m < n; m++)
  581.                             {
  582.                                 for (int p = m + 1; p < n; p++)
  583.                                 {
  584.                                     for (int q = p + 1; q < n; q++)
  585.                                     {
  586.                                         for (int r = q + 1; r < n; r++)
  587.                                         {
  588.                                             for (int x = r + 1; x < n; x++)
  589.                                             {
  590.                                                 for (int y = r + 1; y < n; y++)
  591.                                                 {
  592.                                                     for (int z = y + 1; z < n; z++)
  593.                                                     {
  594.                                                         for (int a = z + 1; a < n; a++)
  595.                                                         {
  596.                                                             for (int b = a + 1; b < n; b++)
  597.                                                             {
  598.                                                                 for (int c = b + 1; c < n; c++)
  599.                                                                 {
  600.                                                                     for (int d = c + 1; d < n; d++)
  601.                                                                     {
  602.                                                                         sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y] + numbers[z] + numbers[a] + numbers[b] + numbers[c] + numbers[d];
  603.                                                                         if (sum == s)
  604.                                                                         {
  605.                                                                             subsetsCount++;
  606.                                                                         }
  607.                                                                     }
  608.                                                                    
  609.                                                                 }
  610.  
  611.                                                             }
  612.  
  613.                                                         }
  614.  
  615.                                                     }
  616.  
  617.                                                 }
  618.  
  619.                                             }
  620.  
  621.                                         }
  622.  
  623.                                     }
  624.  
  625.                                 }
  626.  
  627.                             }
  628.                         }
  629.  
  630.                     }
  631.                 }
  632.             }
  633.         }
  634.         else
  635.         {
  636.             Console.WriteLine(subsetsCount);
  637.             return;
  638.         }
  639.         if (n >= 16)
  640.         {
  641.             for (int i = 0; i < n; i++)
  642.             {
  643.                 for (int j = i + 1; j < n; j++)
  644.                 {
  645.                     for (int k = j + 1; k < n; k++)
  646.                     {
  647.                         for (int l = k + 1; l < n; l++)
  648.                         {
  649.                             for (int m = l + 1; m < n; m++)
  650.                             {
  651.                                 for (int p = m + 1; p < n; p++)
  652.                                 {
  653.                                     for (int q = p + 1; q < n; q++)
  654.                                     {
  655.                                         for (int r = q + 1; r < n; r++)
  656.                                         {
  657.                                             for (int x = r + 1; x < n; x++)
  658.                                             {
  659.                                                 for (int y = r + 1; y < n; y++)
  660.                                                 {
  661.                                                     for (int z = y + 1; z < n; z++)
  662.                                                     {
  663.                                                         for (int a = z + 1; a < n; a++)
  664.                                                         {
  665.                                                             for (int b = a + 1; b < n; b++)
  666.                                                             {
  667.                                                                 for (int c = b + 1; c < n; c++)
  668.                                                                 {
  669.                                                                     for (int d = c + 1; d < n; d++)
  670.                                                                     {
  671.                                                                         for (int e = 0; e < n; e++)
  672.                                                                         {
  673.                                                                             sum = numbers[i] + numbers[j] + numbers[k] + numbers[l] + numbers[m] + numbers[p] + numbers[q] + numbers[r] + numbers[x] + numbers[y] + numbers[z] + numbers[a] + numbers[b] + numbers[c] + numbers[d] + numbers[e];
  674.                                                                             if (sum == s)
  675.                                                                             {
  676.                                                                                 subsetsCount++;
  677.                                                                             }  
  678.                                                                         }
  679.                                                                        
  680.                                                                     }
  681.  
  682.                                                                 }
  683.  
  684.                                                             }
  685.  
  686.                                                         }
  687.  
  688.                                                     }
  689.  
  690.                                                 }
  691.  
  692.                                             }
  693.  
  694.                                         }
  695.  
  696.                                     }
  697.  
  698.                                 }
  699.  
  700.                             }
  701.                         }
  702.  
  703.                     }
  704.                 }
  705.             }
  706.         }
  707.         else
  708.         {
  709.             Console.WriteLine(subsetsCount);
  710.             return;
  711.         }
  712.         Console.WriteLine(subsetsCount);
  713.     }
  714. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement