#include <stdio.h>
#include <limits.h>

#define N 		4
#define FLT_MAX         3.402823466e+38F
#define FLT_MIN         1.175494351e-38F

int main() {
	float a[N][N], b[N], c[N], d[N], e, max;
	int i, j, p;
	printf("e = ");
	scanf("%f", &e);
	max = FLT_MIN;
	for (i = 0; i < N; i++) {
		b[i] = FLT_MAX;
		c[i] = FLT_MIN;
		for (j = 0; j < N; j++) {
			printf("a[%d][%d] = ", i + 1, j + 1);
			scanf("%f", &a[i][j]);
			if (a[i][j] > c[i]) {
				c[i] = a[i][j];
			}
			if (a[i][j] < b[i]) {
				b[i] = a[i][j];
			}
			d[i] = e * c[i] + (1-e) * b[i];
			if (d[i] > max) {
				max = d[i];
				p = i;
			}
		}
	}
	printf("Maximum is D[%d] = %f\n", p, max);
	return 0;
}

//.h file code:

#include <string>
#include <vector>
#include <iostream>
#include "stringconverter.h"

//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System;
//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System::Collections::Generic;
//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System::Linq;
//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System::Text;
class TreeCompare : public IComparer<KeyValuePair<std::wstring, int>*>
{
public:
int Compare(KeyValuePair<std::wstring, int> kvp1, KeyValuePair<std::wstring, int> kvp2);
};

class HaffmanTree
{
private:
std::vector<KeyValuePair<std::wstring, int>*> tree;
std::vector<KeyValuePair<std::wstring, bool>*> listOfFreeNodes;
public:
HaffmanTree(wchar_t arraOfFrequency[], int countOfFrequency[]);

private:
void BuildListOfFreeNodes();

bool IsFreeElement(const std::wstring &key);

public:
void BuildTree();

void ShowHaffmanTree();
};

//----------------------------------------------------------------------------------------
//	Copyright © 2004 - 2013 Tangible Software Solutions Inc.
//	This class can be used by anyone provided that the copyright notice remains intact.
//
//	This class is used to replace some conversions to or from strings.
//----------------------------------------------------------------------------------------
#include <sstream>

class StringConverterHelper
{
public:
	template<typename T>
	static std::wstring toString(const T &subject)
	{
		std::wostringstream ss;
		ss << subject;
		return ss.str();
	}

	template<typename T>
	static T fromString(const std::wstring &subject)
	{
		std::wistringstream ss(subject);
		T target;
		ss >> target;
		return target;
	}
};

//.cpp file code:

//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System;
//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System::Collections::Generic;
//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System::Linq;
//C# TO C++ CONVERTER TODO TASK: The .NET System namespace is not available from native C++:
//using namespace System::Text;

int TreeCompare::Compare(KeyValuePair<std::wstring, int> kvp1, KeyValuePair<std::wstring, int> kvp2)
{
return kvp1.Value->compare(kvp2.Value);
}

HaffmanTree::HaffmanTree(wchar_t arraOfFrequency[], int countOfFrequency[])
{
std::wstring strArrayOfFrequency[sizeof(arraOfFrequency) / sizeof(arraOfFrequency[0])];
for (int i = 0; i < sizeof(strArrayOfFrequency) / sizeof(strArrayOfFrequency[0]); i++)
{
strArrayOfFrequency[i] = StringConverterHelper::toString(arraOfFrequency[i]);
}

tree = std::vector<KeyValuePair<std::wstring, int>*>();
for (int i = 0; i < sizeof(arraOfFrequency) / sizeof(arraOfFrequency[0]); i++)
{
tree.Insert(i, KeyValuePair<std::wstring, int>(strArrayOfFrequency[i], countOfFrequency[i]));
}

listOfFreeNodes = std::vector<KeyValuePair<std::wstring, bool>*>();
}

void HaffmanTree::BuildListOfFreeNodes()
{
for (auto node : tree)
{
listOfFreeNodes.push_back(KeyValuePair<std::wstring, bool>(node.first, true));
}
}

bool HaffmanTree::IsFreeElement(const std::wstring &key)
{
return listOfFreeNodes.Any([&] (void *node)
{
	key == node::Key && node->Value == true;
});
}

void HaffmanTree::BuildTree()
{
IComparer<KeyValuePair<std::wstring, int>*> *comparer = new TreeCompare();
tree.Sort(comparer);
BuildListOfFreeNodes();
int countTrueValue = 0;
while (countTrueValue != 1)
{
int indMin1 = 0, indMin2 = 0;
int min1 = int::MaxValue, min2 = int::MaxValue;
std::wstring keyMin1 = L"";
std::wstring keyMin2 = L"";
//C# TO C++ CONVERTER TODO TASK: The following line could not be converted:
foreach (KeyValuePair<string, int> kvp in tree.Where([&] (void *kvp)
{
	kvp->Value < min1 && IsFreeElement(kvp::Key);
}))
{
keyMin1 = kvp::Key;
indMin1 = tree.find(kvp);
min1 = kvp->Value;
listOfFreeNodes[indMin1] = KeyValuePair<std::wstring, bool>(keyMin1, false);
//C# TO C++ CONVERTER TODO TASK: The following line could not be converted:
foreach (KeyValuePair<string, int> kvp2 in tree.Where([&] (void *kvp2)
{
	kvp2->Value < min2 && (kvp2->Value == min1 || kvp2->Value > min1) && kvp2::Key != keyMin1 && IsFreeElement(kvp2::Key);
}))
{
indMin2 = tree.find(kvp2);
min2 = kvp2->Value;
keyMin2 = kvp2::Key;
}
listOfFreeNodes[indMin2] = KeyValuePair<std::wstring, bool>(keyMin2, false);
}
std::wstring result = keyMin1 + keyMin2;
tree.push_back(KeyValuePair<std::wstring, int>(result, min1 + min2));
listOfFreeNodes.push_back(KeyValuePair<std::wstring, bool>(result, true));
countTrueValue = listOfFreeNodes.size()([&] (void *kvp)
{
	kvp->Value == true;
});
}
}

void HaffmanTree::ShowHaffmanTree()
{
std::cout << std::wstring(L"Tree") << std::endl;
for (auto node : tree)
{
std::cout << node.first << std::wstring(L" ") << node.second << std::endl;
}
std::cout << std::endl;
std::cout << std::wstring(L"List of free nodes") << std::endl;
for (auto node : listOfFreeNodes)
{
std::cout << node.first << std::wstring(L" ") << node.second << std::endl;
}
}

//.h file code:

#include <string>
#include <vector>
#include <iostream>
#include <sstream>

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;
using namespace System::Text;

class TreeCompare : public IComparer<KeyValuePair<std::wstring, int>*>
{
public:
int Compare(KeyValuePair<std::wstring, int> kvp1, KeyValuePair<std::wstring, int> kvp2);
};

class HaffmanTree
{
private:
std::vector<KeyValuePair<std::wstring, int>*> tree;
std::vector<KeyValuePair<std::wstring, bool>*> listOfFreeNodes;
public:
HaffmanTree(wchar_t arraOfFrequency[], int countOfFrequency[]);

private:
void BuildListOfFreeNodes();

bool IsFreeElement(const std::wstring &key);

public:
void BuildTree();

void ShowHaffmanTree();
};

class StringConverterHelper
{
public:
	template<typename T>
	static std::wstring toString(const T &subject)
	{
		std::wostringstream ss;
		ss << subject;
		return ss.str();
	}

	template<typename T>
	static T fromString(const std::wstring &subject)
	{
		std::wistringstream ss(subject);
		T target;
		ss >> target;
		return target;
	}
};

int TreeCompare::Compare(KeyValuePair<std::wstring, int> kvp1, KeyValuePair<std::wstring, int> kvp2)
{
return kvp1.Value->compare(kvp2.Value);
}

HaffmanTree::HaffmanTree(wchar_t arraOfFrequency[], int countOfFrequency[])
{
std::wstring strArrayOfFrequency[sizeof(arraOfFrequency) / sizeof(arraOfFrequency[0])];
for (int i = 0; i < sizeof(strArrayOfFrequency) / sizeof(strArrayOfFrequency[0]); i++)
{
strArrayOfFrequency[i] = StringConverterHelper::toString(arraOfFrequency[i]);
}

tree = std::vector<KeyValuePair<std::wstring, int>*>();
for (int i = 0; i < sizeof(arraOfFrequency) / sizeof(arraOfFrequency[0]); i++)
{
tree.Insert(i, KeyValuePair<std::wstring, int>(strArrayOfFrequency[i], countOfFrequency[i]));
}

listOfFreeNodes = std::vector<KeyValuePair<std::wstring, bool>*>();
}

void HaffmanTree::BuildListOfFreeNodes()
{
for (auto node : tree)
{
listOfFreeNodes.push_back(KeyValuePair<std::wstring, bool>(node.first, true));
}
}

bool HaffmanTree::IsFreeElement(const std::wstring &key)
{
return listOfFreeNodes.Any([&] (void *node)
{
	key == node::Key && node->Value == true;
});
}

void HaffmanTree::BuildTree()
{
IComparer<KeyValuePair<std::wstring, int>*> *comparer = new TreeCompare();
tree.Sort(comparer);
BuildListOfFreeNodes();
int countTrueValue = 0;
while (countTrueValue != 1)
{
int indMin1 = 0, indMin2 = 0;
int min1 = int::MaxValue, min2 = int::MaxValue;
std::wstring keyMin1 = L"";
std::wstring keyMin2 = L"";
//C# TO C++ CONVERTER TODO TASK: The following line could not be converted:
foreach (KeyValuePair<string, int> kvp in tree.Where([&] (void *kvp)
{
	kvp->Value < min1 && IsFreeElement(kvp::Key);
}))
{
keyMin1 = kvp::Key;
indMin1 = tree.find(kvp);
min1 = kvp->Value;
listOfFreeNodes[indMin1] = KeyValuePair<std::wstring, bool>(keyMin1, false);
//C# TO C++ CONVERTER TODO TASK: The following line could not be converted:
foreach (KeyValuePair<string, int> kvp2 in tree.Where([&] (void *kvp2)
{
	kvp2->Value < min2 && (kvp2->Value == min1 || kvp2->Value > min1) && kvp2::Key != keyMin1 && IsFreeElement(kvp2::Key);
}))
{
indMin2 = tree.find(kvp2);
min2 = kvp2->Value;
keyMin2 = kvp2::Key;
}
listOfFreeNodes[indMin2] = KeyValuePair<std::wstring, bool>(keyMin2, false);
}
std::wstring result = keyMin1 + keyMin2;
tree.push_back(KeyValuePair<std::wstring, int>(result, min1 + min2));
listOfFreeNodes.push_back(KeyValuePair<std::wstring, bool>(result, true));
countTrueValue = listOfFreeNodes.size()([&] (void *kvp)
{
	kvp->Value == true;
});
}
}

void HaffmanTree::ShowHaffmanTree()
{
std::cout << std::wstring(L"Tree") << std::endl;
for (auto node : tree)
{
std::cout << node.first << std::wstring(L" ") << node.second << std::endl;
}
std::cout << std::endl;
std::cout << std::wstring(L"List of free nodes") << std::endl;
for (auto node : listOfFreeNodes)
{
std::cout << node.first << std::wstring(L" ") << node.second << std::endl;
}
}

void main() {
}

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Linq;
using namespace System::Text;

private ref class TreeCompare : IComparer<KeyValuePair<String^, int>^>
{
public:
	virtual int Compare(KeyValuePair<String^, int> kvp1, KeyValuePair<String^, int> kvp2) sealed;
};

private ref class HaffmanTree
{
private:
	List<KeyValuePair<String^, int>^> ^tree;
	List<KeyValuePair<String^, bool>^> ^listOfFreeNodes;
public:
	HaffmanTree(array<Char> ^arraOfFrequency, array<int> ^countOfFrequency);

private:
	void BuildListOfFreeNodes();

	bool IsFreeElement(String ^key);

public:
	void BuildTree();

private:
void AnonymousMethod1(Object ^kvp);

public:
	void ShowHaffmanTree();
};

int TreeCompare::Compare(KeyValuePair<String^, int> kvp1, KeyValuePair<String^, int> kvp2)
{
	return kvp1.Value->CompareTo(kvp2.Value);
}

HaffmanTree::HaffmanTree(array<Char> ^arraOfFrequency, array<int> ^countOfFrequency)
{
	array<String^> ^strArrayOfFrequency = gcnew array<String^>(arraOfFrequency->Length);
	for (int i = 0; i < strArrayOfFrequency->Length; i++)
	{
		strArrayOfFrequency[i] = Convert::ToString(arraOfFrequency[i]);
	}

	tree = gcnew List<KeyValuePair<String^, int>^>();
	for (int i = 0; i < arraOfFrequency->Length; i++)
	{
		tree->Insert(i, KeyValuePair<String^, int>(strArrayOfFrequency[i], countOfFrequency[i]));
	}

	listOfFreeNodes = gcnew List<KeyValuePair<String^, bool>^>();
}

void HaffmanTree::BuildListOfFreeNodes()
{
	for each (KeyValuePair<String^, int> ^node in tree)
	{
		listOfFreeNodes->Add(KeyValuePair<String^, bool>(node.Key, true));
	}
}

bool HaffmanTree::IsFreeElement(String ^key)
{
	return listOfFreeNodes->Any(delegate(Object^ node));
	{
		key == node::Key && node->Value == true;
	}
}

void HaffmanTree::BuildTree()
{
	IComparer<KeyValuePair<String^, int>^> ^comparer = gcnew TreeCompare();
	tree->Sort(comparer);
	BuildListOfFreeNodes();
	int countTrueValue = 0;
	while (countTrueValue != 1)
	{
		int indMin1 = 0, indMin2 = 0;
		int min1 = int::MaxValue, min2 = int::MaxValue;
		String ^keyMin1 = String::Empty;
		String ^keyMin2 = String::Empty;
		for each (KeyValuePair<String^, int> ^kvp in tree->Where(delegate(Object^ kvp)))
		{
			kvp.Value < min1 && IsFreeElement(kvp.Key);
		}
		{
			keyMin1 = kvp::Key;
			indMin1 = tree->IndexOf(kvp);
			min1 = kvp->Value;
			listOfFreeNodes[indMin1] = KeyValuePair<String^, bool>(keyMin1, false);
			for each (KeyValuePair<String^, int> ^kvp2 in tree->Where(delegate(Object^ kvp2)))
			{
				kvp2.Value < min2 && (kvp2.Value == min1 || kvp2.Value > min1) && kvp2.Key != keyMin1 && IsFreeElement(kvp2.Key);
			}
			{
				indMin2 = tree->IndexOf(kvp2);
				min2 = kvp2->Value;
				keyMin2 = kvp2::Key;
			}
			listOfFreeNodes[indMin2] = KeyValuePair<String^, bool>(keyMin2, false);
		}
		String ^result = keyMin1 + keyMin2;
		tree->Add(KeyValuePair<String^, int>(result, min1 + min2));
		listOfFreeNodes->Add(KeyValuePair<String^, bool>(result, true));
		countTrueValue = listOfFreeNodes->Count(AnonymousMethod1);
	}
}

void HaffmanTree::AnonymousMethod1(Object ^kvp)
{
		kvp->Value == true;
}

void HaffmanTree::ShowHaffmanTree()
{
	Console::WriteLine("Tree");
	for each (KeyValuePair<String^, int> ^node in tree)
	{
		Console::WriteLine("{0} {1}", node.Key, node.Value);
	}
	Console::WriteLine();
	Console::WriteLine("List of free nodes");
	for each (KeyValuePair<String^, bool> ^node in listOfFreeNodes)
	{
		Console::WriteLine("{0} {1}", node.Key, node.Value);
	}
}

int main(array<System::String ^> ^args)
{
	Console::WriteLine(L"Hello World");
	return 0;
}