C# と VB.NET の質問掲示板

上記の考え方をそのまま実装してみたところコード実行速度5位メモリ使用量低で正答できました。
ここから先の高速化とかはあまり考えてないので。
もし高速化できそうなところがあったらご指摘ください。


#include<stdio.h>
#include<string.h>

const int A=0;//二人をAさんBさんとする
const int B=1;

void setData(int n){
	int memo[2][5002];//[次にもらうのがAさん＝0　Bさん＝1][Aさんがここまででもらった個数]=最小切断時間
	int next[2][5002];//次の切断箇所の検討
	int cutTimes[10001];//切断時間
	int cutTime,herf=n/2,nowTime;
	int up;

	for(int i=0;i<n-1;i++)scanf("%d",&cutTimes[i]);
	
	memset(memo,127,sizeof(memo));//足される切断秒数は10000なのでオーバーフローしない
	memo[A][1]=0;//計算しやすいようAさんが1個目を取得した状態から始める
	
	for(int turn=0;turn<n-1;turn++){
		memset(next,127,sizeof(next));//ダミーデータ
		cutTime=cutTimes[turn];//切断箇所をずらしていく

		up=turn+1>herf?herf:turn+1;//上限
		for(int k=1;k<=up;k++){
			nowTime=memo[A][k];//Aさん
			
			//切断せずAさんが続けてもらう
			next[A][k+1]=nowTime;
			
			//切断して次はBさんがもらう
			next[B][k]=nowTime+cutTime;
		}
		for(int k=1;k<=up;k++){
			//Bさんの番
			nowTime=memo[B][k];
			//Bさんが続けてもらう
			next[B][k]=next[B][k]>nowTime?nowTime:next[B][k];
			
			//Aさんがもらう
			nowTime+=cutTime;
			next[A][k+1]=next[A][k+1]>nowTime?nowTime:next[A][k+1];
		}
		memcpy(memo,next,sizeof(next));
	}
	nowTime=memo[A][herf]>memo[B][herf]?memo[B][herf]:memo[A][herf];
	
	printf("%d\n",nowTime);
}

int main(){
	int n;
	scanf("%d",&n);
	setData(n);
	while(scanf("%d",&n)!=EOF){
	}
}

C#, Visual Studio 2013 Commnunity Update4, EF6.0

お世話になります。

Entityframework のデータベースの設計についてご相談したいと思い投稿させて頂きました。

現在、 CSV からデータを読み込み Entityframewrok のモデルへとインポートするということをしています。

CSV の種類と項目は下記のような感じです。

【発注元CSV】
発注元コード, 発注元名
100, A社
101, B社
102, C社

【納品先CSV】
納品先コード, 納品先名, 発注元コード, 発注元名
1, 東京, 100, A社
2, 千葉, 100, A社
3, 神奈川, 100, A社
1, 東京, 101, B社
2, 神奈川, 101, B社
3, 長野, 101, B社
1, 東京, 102, C社
2, 北海道, 102, C社

【オーダーCSV】
オーダーNo, オーダー詳細No, 発注元コード, 発注元名, 納品先コード, 納品先名
10001, 1, 100, A社, 1, 東京
10001, 2, 100, A社, 2, 千葉
10002, 1, 101, B社, 1, 東京
10003, 1, 102, C者, 2, 北海道
10004, 1, 100, A社, 0, (空文字)

上記の CSV のインポート先に下記のようなモデルを使っています。

class 発注元
{
   [Key]
   public int コード {get; set;}
   public string 名前 {get; set;}

   public virtual ICollection<納品先> 納品先s {get ;set;}
}

class 納品先
{
   [Key, Column(Order = 0)]
   public int コード {get; set;}
   [Key, Column(Order = 0)]
   public int 発注元コード {get; set;}
   public string 名前 {get; set;} 
   
   [ForeignKey("発注元コード")]
   public virtual 発注元 発注元 {get ;set;}
   public virtual ICollection<オーダー> オーダーs {get; set;}
}

class オーダー
{
   [Key, Column(Order=0)]
   public int オーダーNo {get; set;}
   [Key, Column(Order=1)]
   public int オーダー詳細No {get; set;}
   [ForeignKey("納品先"), Column(Order=2)]
   public int 発注元コード {get; set;}
   [ForeignKey("納品先"), Column(Order=3)]
   public int 納品先コード { get; set;}
   
   public virtual 納品先 納品先 {get; set;}
}

処理的には、オーダー CSV から発注元コードと納品先コードの組み合わせを全て抽出し、
発注元モデルと納品先モデルへと登録後、

改めて、オーダー CSV の発注元名と納品先名を除いた No とコードを上記のモデルに入れています。

理想的には、下記のようなオーダーモデルに入れて、

class オーダー
{
   [Key, Column(Order=0)]
   public int オーダーNo {get; set;}
   [Key, Column(Order=1)]
   public int オーダー詳細No {get; set;}

   public virtual 発注元 発注元 {get; set;}   
   public virtual 納品先 納品先 {get; set;}
}

オーダーからの発注元と納品先の情報の取得を分かりやすくしたいのですが、
発注元はともかく納品先が複合キーになっているので、出来ない状態です。

なにか Fluent API 等で対処できるといいなと思って探っている状態なのですが・・・

もっと良いモデルの設計や、Fulent API の設定等で何かあれば、ご助言を頂けると幸いです。

宜しくお願い致します。

■No82952 (774RR さん) に追記
> 1.000000000000 と
> 0.999999999999 と
> 1.000000000001 とは違う数値になっちゃう。

1.000000000001 は、内部的には (2^0 +2^-40 +2^-44 +2^-45 +2^-48 +2^-49) 相当ですね。

「^」は、VB/VBA の冪演算子。（C# だと Math.Pow）


Double バイナリを 2 進数で表記

1.000000000000 → 0 01111111111 0000000000000000000000000000000000000000000000000000
0.999999999999 → 0 01111111110 1111111111111111111111111111111111111101110011010001
1.000000000001 → 0 01111111111 0000000000000000000000000000000000000001000110011000

0.99999999999999978 → 0 01111111110 1111111111111111111111111111111111111111111111111110
0.99999999999999989 → 0 01111111110 1111111111111111111111111111111111111111111111111111
1.00000000000000000 → 0 01111111111 0000000000000000000000000000000000000000000000000000
1.00000000000000020 → 0 01111111111 0000000000000000000000000000000000000000000000000001


上記の Double バイナリを 10進小数に復元

1.000000000000 →  1.00000000000000000000000000000000000000000000000000000
0.999999999999 →  0.99999999999900002212172012150404043495655059814453125
1.000000000001 →  1.00000000000100008890058234101161360740661621093750000

0.99999999999999978 → 0.99999999999999977795539507496869191527366638183593750
0.99999999999999989 → 0.99999999999999988897769753748434595763683319091796875
1.00000000000000000 → 1.00000000000000000000000000000000000000000000000000000
1.00000000000000020 → 1.00000000000000022204460492503130808472633361816406250