結果
| 問題 | No.733 分身並列コーディング |
| コンテスト | |
| ユーザー |
 りあん
|
| 提出日時 | 2017-08-26 18:44:49 |
| 言語 | C#(csc) (csc 3.9.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 12,934 bytes |
| 記録 | |
| コンパイル時間 | 1,245 ms |
| コンパイル使用メモリ | 121,144 KB |
| 実行使用メモリ | 35,816 KB |
| 最終ジャッジ日時 | 2024-10-15 17:52:13 |
| 合計ジャッジ時間 | 46,167 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 36 WA * 10 |
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 3.9.0-6.21124.20 (db94f4cc) Copyright (C) Microsoft Corporation. All rights reserved.
ソースコード
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.IO;
using System.Text;
using System.Diagnostics;
using Binary = System.Func<System.Linq.Expressions.ParameterExpression, System.Linq.Expressions.ParameterExpression, System.Linq.Expressions.BinaryExpression>;
using Unary = System.Func<System.Linq.Expressions.ParameterExpression, System.Linq.Expressions.UnaryExpression>;
class Program
{
static StreamWriter sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
static Scan sc = new Scan();
const int M = 1000000007;
const double eps = 1e-11;
static readonly int[] dd = { 0, 1, 0, -1, 0 };
static void Main()
{
int T = sc.Int;
int n = sc.Int;
var dp = new int[1 << n][];
var t = new int[n];
for (int i = 0; i < n; i++)
{
t[i] = sc.Int;
}
var bp = new BinPackingApp.BinPacking();
bp.BinSize = T;
int ans = bp.Solve(t).Count;
var r = new Random();
var stw = new Stopwatch();
stw.Start();
while (stw.ElapsedMilliseconds < 1000)
{
var s = t.copy();
var p = new int[n];
for (int i = 0; i < n; i++)
{
p[i] = r.Next(100);
}
Array.Sort(p, s);
int c = 0, rem = 0;
for (int i = 0; i < n; i++)
{
if (rem < s[i]) {
++c;
rem = T - s[i];
}
else
rem -= s[i];
}
if (c < ans) {
ans = c;
break;
}
}
Prt(ans);
sw.Flush();
}
static void swap<T>(ref T a, ref T b) { var t = a; a = b; b = t; }
static T Max<T>(params T[] a) { return a.Max(); }
static T Min<T>(params T[] a) { return a.Min(); }
static void DBG(string a) { Console.WriteLine(a); }
static void Prt(string a) { sw.WriteLine(a); }
static void DBG<T>(IEnumerable<T> a) { DBG(string.Join(" ", a)); }
static void DBG(params object[] a) { DBG(string.Join(" ", a)); }
static void Prt<T>(IEnumerable<T> a) { Prt(string.Join(" ", a)); }
static void Prt(params object[] a) { Prt(string.Join(" ", a)); }
// for AOJ
// static string Join<T>(string sep, IEnumerable<T> a) { return string.Join(sep, a.Select(x => x.ToString()).ToArray()); }
// static void DBG<T>(IEnumerable<T> a) { DBG(Join(" ", a)); }
// static void DBG(params object[] a) { DBG(Join(" ", a)); }
// static void Prt<T>(IEnumerable<T> a) { Prt(Join(" ", a)); }
// static void Prt(params object[] a) { Prt(Join(" ", a)); }
}
static class ex
{
public static void swap<T>(this IList<T> a, int i, int j) { var t = a[i]; a[i] = a[j]; a[j] = t; }
public static T[] copy<T>(this IList<T> a)
{
var ret = new T[a.Count];
for (int i = 0; i < a.Count; i++) ret[i] = a[i];
return ret;
}
}
static class Operator<T>
{
static readonly ParameterExpression x = Expression.Parameter(typeof(T), "x");
static readonly ParameterExpression y = Expression.Parameter(typeof(T), "y");
public static readonly Func<T, T, T> Add = Lambda(Expression.Add);
public static readonly Func<T, T, T> Subtract = Lambda(Expression.Subtract);
public static readonly Func<T, T, T> Multiply = Lambda(Expression.Multiply);
public static readonly Func<T, T, T> Divide = Lambda(Expression.Divide);
public static readonly Func<T, T> Plus = Lambda(Expression.UnaryPlus);
public static readonly Func<T, T> Negate = Lambda(Expression.Negate);
public static Func<T, T, T> Lambda(Binary op) { return Expression.Lambda<Func<T, T, T>>(op(x, y), x, y).Compile(); }
public static Func<T, T> Lambda(Unary op) { return Expression.Lambda<Func<T, T>>(op(x), x).Compile(); }
}
class Scan
{
public int Int { get { return int.Parse(Str); } }
public long Long { get { return long.Parse(Str); } }
public double Double { get { return double.Parse(Str); } }
public string Str { get { return Console.ReadLine().Trim(); } }
public int[] IntArr { get { return StrArr.Select(int.Parse).ToArray(); } }
public long[] LongArr { get { return StrArr.Select(long.Parse).ToArray(); } }
public double[] DoubleArr { get { return StrArr.Select(double.Parse).ToArray(); } }
public string[] StrArr { get { return Str.Split(); } }
bool eq<T, U>() { return typeof(T).Equals(typeof(U)); }
T ct<T, U>(U a) { return (T)Convert.ChangeType(a, typeof(T)); }
T cv<T>(string s) { return eq<T, int>() ? ct<T, int>(int.Parse(s))
: eq<T, long>() ? ct<T, long>(long.Parse(s))
: eq<T, double>() ? ct<T, double>(double.Parse(s))
: eq<T, char>() ? ct<T, char>(s[0])
: ct<T, string>(s); }
public void Multi<T>(out T a) { a = cv<T>(Str); }
public void Multi<T, U>(out T a, out U b)
{ var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); }
public void Multi<T, U, V>(out T a, out U b, out V c)
{ var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); }
public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d)
{ var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); }
public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
{ var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]); }
public void Multi<T, U, V, W, X, Y>(out T a, out U b, out V c, out W d, out X e, out Y f)
{ var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]); f = cv<Y>(ar[5]); }
public void Multi<T, U, V, W, X, Y, Z>(out T a, out U b, out V c, out W d, out X e, out Y f, out Z g)
{ var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]); f = cv<Y>(ar[5]); g = cv<Z>(ar[6]);}
}
// http://gushwell.ifdef.jp/etude/BinPacking.html より
namespace BinPackingApp {
// 必ずしも最適解が求まるとは限らない
class BinPacking {
public int BinSize { get; set; }
public BinPacking() {
BinSize = 100;
}
public ICollection<ICollection<int>> Solve(int[] items) {
var r1 = Solve04(items); // 一般的な解法
var r2 = Solve03(items); // 場合によっては、こちらが良い答えを出す場合もある。
// どちらか良いほうを返す。
if (r1.Count() > r2.Count())
return r2;
return r1;
}
// 解法０１：最も空きが多いビンに入れてゆく解法
public ICollection<ICollection<int>> Solve01(int[] items) {
// 最低限必要なビンを用意し、listに入れる
int total = items.Sum();
int bincount = total / BinSize + ((total % BinSize == 0) ? 0 : 1);
List<ICollection<int>> binList = new List<ICollection<int>>();
for (int i = 0; i < bincount; i++) {
List<int> bin = new List<int>();
binList.Add(bin);
}
// 各項目をビンに入れてゆく
foreach (var n in items.OrderByDescending(a => a)) {
// nが入るビンを見つける （最も空いているビン）
var target = binList.Select(b => new { Bin = b, Space = BinSize - b.Sum(t => t) })
.Where(x => x.Space >= n)
.OrderByDescending(x => x.Space);
var first = target.FirstOrDefault();
if (first != null) {
// nが入るビンが見つかったので、そこに入れる
target.First().Bin.Add(n);
} else {
// 見つからなかったので、新しいビンを用意する
List<int> bin2 = new List<int>() { n };
binList.Add(bin2);
}
}
return binList;
}
// 解法０２：最も空きが少ないビンに入れてゆく解法
public ICollection<ICollection<int>> Solve02(int[] items) {
// 最初に用意するビンはひとつ
List<ICollection<int>> binList = new List<ICollection<int>>();
List<int> bin = new List<int>();
binList.Add(bin);
// 各項目をビンに入れてゆく
foreach (var n in items.OrderByDescending(t => t)) {
// nが入るビンを見つける （空きが最も少ないビン）
var target = binList.Select(b => new { Bin = b, Space = BinSize - b.Sum(t => t) })
.Where(x => x.Space >= n)
.OrderBy(x => x.Space);
var first = target.FirstOrDefault();
if (first != null) {
// ビンが見つかったら、ビンに詰める
first.Bin.Add(n);
} else {
// 見つからなかったので新たなビンに詰める
List<int> bin2 = new List<int>() { n };
binList.Add(bin2);
}
}
return binList;
}
// 解法０３：解法02を繰り返し使う独自のやり方
public ICollection<ICollection<int>> Solve03(int[] items) {
List<ICollection<int>> result = new List<ICollection<int>>();
// 解法02を使い、一旦答えを求める
var binsList = Solve02(items);
while (true) {
// 空きの小さい順に並べ替え、
// 空きが最も小さいビンを最終解答領域(result)へ入れる（確定）
var bin = binsList.OrderByDescending(b => b.Sum())
.First();
result.Add(bin);
// listから確定したビンを取り除く
binsList.Remove(bin);
// 残ったビンは無いので、処理終了
if (binsList.Count == 0)
break;
// 残ったビンに入っている項目で、再度、[解法02]で瓶詰めをする
binsList = Solve02(GetSequence(binsList).ToArray());
}
return result;
}
// 解法０４：解法０１の変形
public ICollection<ICollection<int>> Solve04(int[] items) {
// 最低限必要なビンを用意し、listに入れる
int total = items.Sum();
int bincount = total / BinSize + ((total % BinSize == 0) ? 0 : 1);
List<ICollection<int>> list = new List<ICollection<int>>();
for (int i = 0; i < bincount; i++) {
List<int> bin = new List<int>();
list.Add(bin);
}
// 各項目をビンに入れてゆく
foreach (var n in items.OrderByDescending(a => a)) {
// nが入るビンを見つける （ぴったりに入るビン）
var target = list.Select(b => new { Bin = b, Space = BinSize - b.Sum(t => t) })
.Where(x => x.Space == n);
var first = target.FirstOrDefault();
if (first != null) {
// nが入るビンが見つかったので、そこに入れる
first.Bin.Add(n);
} else {
// nが入るビンを見つける （最も空いているビン）
target = list.Select(b => new { Bin = b, Space = BinSize - b.Sum(t => t) })
.Where(x => x.Space >= n)
.OrderByDescending(x => x.Space);
var first2 = target.FirstOrDefault();
if (first2 != null) {
// nが入るビンが見つかったので、そこに入れる
first2.Bin.Add(n);
} else {
// 見つからなかったので、新しいビンを用意する
List<int> bin2 = new List<int>() { n };
list.Add(bin2);
}
}
}
return list;
}
// ビンに詰められている全ての要素を順に取り出す
public IEnumerable<int> GetSequence(ICollection<ICollection<int>> list) {
foreach (var bin in list)
foreach (var n in bin)
yield return n;
}
}
}