public int DepthSum(IList <NestedInteger> nestedList)
{
if (!nestedList.Any())
{
return(0);
}
Queue <NestedInteger> queue = new Queue <NestedInteger>(nestedList);
int depth = 1;
int total = 0;
while (queue.Count > 0)
{
for (int i = 0; i < queue.Count; i++)
{
NestedInteger nested = queue.Dequeue();
if (nested.IsInteger())
{
total += nested.GetInteger() * depth;
}
else
{
foreach (var n in nested.GetList())
{
queue.Enqueue(n);
}
}
}
depth++;
}
return(total);
}
public bool HasNext()
{
if (curr.Count != curri)
{
NestedInteger n = curr[curri];
if (n.IsInteger())
{
return(true);
}
// Push nested list early
q.Push(curr);
qi.Push(++curri); /* record next starting iteration */
curr = n.GetList();
curri = 0;
return(HasNext());
}
if (q.Count != 0)
{
curr = q.Pop();
curri = qi.Pop();
return(HasNext());
}
return(false);
}
public void NestedIterator_2()
{
var input3 = new NestedInteger();
input3.Add(new NestedInteger(6));
var input2 = new NestedInteger();
input2.Add(new NestedInteger(4));
input2.Add(input3);
var input1 = new NestedInteger(1);
var solution = new _0341_FlattenNestedListIterator(new List <NestedInteger>()
{
input1, input2
});
Assert.IsTrue(solution.HasNext());
Assert.AreEqual(1, solution.Next());
Assert.IsTrue(solution.HasNext());
Assert.AreEqual(4, solution.Next());
Assert.IsTrue(solution.HasNext());
Assert.AreEqual(6, solution.Next());
Assert.IsFalse(solution.HasNext());
}
public NestedInteger Deserialize(string s)
{
NestedInteger ret = new NestedInteger();
if (s == null || s.Length == 0)
{
return(ret);
}
if (s[0] != '[')
{
ret.SetInteger(int.Parse(s));
}
else if (s.Length > 2)
{
int start = 1, count = 0;
for (int i = 1; i < s.Length; i++)
{
char c = s[i];
if (count == 0 && (c == ',' || i == s.Length - 1))
{
ret.Add(Deserialize(s.Substring(start, i - start)));
start = i + 1;
}
else if (c == '[')
{
count++;
}
else if (c == ']')
{
count--;
}
}
}
return(ret);
}
public void TestMethod1()
{
// [[1,1],2,[1,1]]
List <NestedInteger> list = new List <NestedInteger>();
NestedInteger ni = new NestedInteger();
ni.Add(new NestedInteger(1));
ni.Add(new NestedInteger(1));
list.Add(ni);
list.Add(new NestedInteger(2));
ni = new NestedInteger();
ni.Add(new NestedInteger(1));
ni.Add(new NestedInteger(1));
list.Add(ni);
NestedIterator nIterator = new NestedIterator(list);
LinkedList <int> elements = new LinkedList <int>();
while (nIterator.HasNext())
{
elements.AddLast(nIterator.Next());
}
CollectionAssert.AreEquivalent(elements.ToArray(), new int[] { 1, 1, 2, 1, 1 });
}
private NestedInteger Recursive(string s, int curIndex, out int nextIndex)
{
nextIndex = curIndex + 1;
var forReturn = new NestedInteger();
var numTemp = 0;
for (int i = curIndex; i < s.Length; i++)
{
var curChar = s[i];
switch (curChar)
{
case '[':
var r = Recursive(s, i + 1, out int ni);
if (r.GetList() == null)
{
forReturn.Add(r);
}
else
{
foreach (var item in r.GetList())
{
forReturn.Add(item);
}
}
i = ni - 1;
break;
case ']':
nextIndex = i + 1;
return(forReturn);
case ',':
if (numTemp != 0)
{
forReturn.Add(new NestedInteger(numTemp));
numTemp = 0;
}
break;
case '-':
numTemp *= -1;
break;
default:
numTemp = numTemp * 10 + int.Parse(curChar.ToString());
break;
}
}
if (numTemp != 0)
{
forReturn.SetInteger(numTemp);
}
return(forReturn);
}
public void NestedIterator_3()
{
var input1 = new NestedInteger();
var solution = new _0341_FlattenNestedListIterator(new List <NestedInteger>()
{
input1
});
Assert.IsFalse(solution.HasNext());
}
static void DFS(NestedInteger integer, int depth, ref int res)
{
if (integer.IsInteger())
{
res += integer.GetInteger() * depth;
return;
}
foreach (var nestedInteger in integer.GetList())
{
DFS(nestedInteger, depth + 1, ref res);
}
}
static void DFS(NestedInteger integer, int height, List <int[]> record, ref int maxHeight)
{
if (integer.IsInteger())
{
maxHeight = Math.Max(maxHeight, height);
record.Add(new[] { integer.GetInteger(), height });
}
foreach (var nestedInteger in integer.GetList())
{
DFS(nestedInteger, height + 1, record, ref maxHeight);
}
}
private void Dfs(NestedInteger ni)
{
if (ni.IsInteger())
{
m_res.Add(ni.GetInteger());
return;
}
foreach (var item in ni.GetList())
{
Dfs(item);
}
}
private NestedInteger Dfs(object item, NestedInteger current)
{
if (item is int)
{
current.SetInteger((int)item);
return(current);
}
foreach (var obj in (object[])item)
{
current.Add(Dfs(obj, new NestedInteger()));
}
return(current);
}
void AddNum(NestedInteger node)
{
if (node.IsInteger())
{
arr.Add(node.GetInteger());
}
else
{
foreach (var item in node.GetList())
{
AddNum(item);
}
}
}
public int Next()
{
if (curr.Count == curri)
{
throw new Exception("Invalid Next");
}
NestedInteger n = curr[curri++];
if (!n.IsInteger())
{
throw new Exception("Invalid Next");
}
return(n.GetInteger());
}
private void DFS(NestedInteger nestedInteger)
{
if (nestedInteger.IsInteger())
{
nums.Add(nestedInteger.GetInteger());
}
else
{
foreach (var item in nestedInteger.GetList())
{
DFS(item);
}
}
}
public void dfs(NestedInteger node)
{
if (node.IsInteger())
{
queue.Enqueue(node.GetInteger());
}
else
{
foreach (var child in node.GetList())
{
dfs(child);
}
}
}
private void DFS(NestedInteger cur)
{
if (cur.IsInteger())
{
q.Enqueue(cur.GetInteger());
}
else
{
foreach (var item in cur.GetList())
{
DFS(item);
}
}
}
private void Helper(NestedInteger integer, Queue <int> previous)
{
if (integer.IsInteger())
{
previous.Enqueue(integer.GetInteger());
}
else
{
foreach (var item in integer.GetList())
{
Helper(item, previous);
}
}
}
private void Add(NestedInteger nestedInteger)
{
if (nestedInteger.IsInteger())
{
list.Add(nestedInteger.GetInteger());
}
else
{
foreach (var i in nestedInteger.GetList())
{
Add(i);
}
}
}
private void PopulateNext(NestedInteger nest)
{
if (nest.IsInteger())
{
//_queue.Enqueue(nest.GetInteger());
return;
}
var list = nest.GetList();
foreach (var n in list)
{
PopulateNext(n);
}
}
// Set this NestedInteger to hold a nested list and adds a nested integer to it.
public void Add(NestedInteger ni)
{
number = null;
if (list == null)
{
list = new List <NestedInteger>()
{
ni
}
}
;
else
{
list.Add(ni);
}
}
public NestedInteger Deserialize(string s)
{
var stack = new Stack <NestedInteger>();
string tokenNum = "";
foreach (char c in s)
{
if (c == '[')
{
stack.Push(new NestedInteger());
}
else if (c == ']')
{
if (tokenNum.Length > 0)
{
stack.Peek().Add(new NestedInteger(Int32.Parse(tokenNum)));
}
NestedInteger ni = stack.Pop(); //本层list结束
tokenNum = "";
if (stack.Count > 0) //栈内有更高层次的list
{
stack.Peek().Add(ni);
}
else //栈为空，遍历到字符串结尾
{
return(ni);
}
}
else if (c == ',')
{
if (tokenNum.Length > 0) //将数字加入到本层list中
{
stack.Peek().Add(new NestedInteger(Int32.Parse(tokenNum)));
}
tokenNum = "";
}
else //number
{
tokenNum += c;
}
}
if (tokenNum.Length > 0)//特殊case: 如果字符串只包含数字的情况
{
return(new NestedInteger(Int32.Parse(tokenNum)));
}
return(null);
}
public NestedInteger Deserialize(string s)
{
var parent = new NestedInteger();
var stack = new Stack <NestedInteger>();
int?num = null;
int sign = 1;
foreach (char c in s)
{
if (c == '[')
{
var list = new NestedInteger();
parent.Add(list);
stack.Push(parent);
parent = list;
}
else if (c == ']' || c == ',')
{
if (num.HasValue)
{
parent.Add(new NestedInteger(num.Value * sign));
num = null;
sign = 1;
}
if (c == ']')
{
parent = stack.Pop();
}
}
else if (c == '-')
{
sign = -1;
}
else
{
num ??= 0;
num = num * 10 + (c - '0');
}
}
if (num.HasValue)
{
parent.Add(new NestedInteger(num.Value * sign));
}
return(parent.GetList()[0]);
}
//static void Main(string[] args)
//{
// NestedInteger first = new NestedInteger()
// {
// List = new List<NestedInteger>()
// {
// new NestedInteger() { Number = 1 },
// new NestedInteger() { Number = 1 }
// }
// };
// NestedInteger second = new NestedInteger()
// {
// Number = 2
// };
// NestedInteger third = new NestedInteger()
// {
// List = new List<NestedInteger>()
// {
// new NestedInteger() { Number = 1 },
// new NestedInteger() { Number = 1 }
// }
// };
// List<NestedInteger> firstList = new List<NestedInteger>
// {
// first,
// second,
// third
// };
// Console.WriteLine($"sum:{ComputeNestedListSum(firstList)}\t expected:10");
// Console.WriteLine($"using recursion: sum:{ComputeNestedListSumRecursive(firstList)}\t expected:10");
// first = new NestedInteger() { Number = 1 };
// second = new NestedInteger()
// {
// List = new List<NestedInteger>()
// {
// new NestedInteger()
// {
// Number = 4
// },
// new NestedInteger()
// {
// List = new List<NestedInteger>()
// {
// new NestedInteger()
// {
// Number = 6
// }
// }
// }
// }
// };
// List<NestedInteger> secondList = new List<NestedInteger>
// {
// first,
// second
// };
// Console.WriteLine($"sum:{ComputeNestedListSum(secondList)}\t expected:27");
// Console.WriteLine($"using recursion: sum:{ComputeNestedListSumRecursive(secondList)}\t expected:27");
// Console.ReadKey();
//}
// Tx = O(n) {n: number of nested integers}
// Sx = O(2n)
// [[1,1],2,[1,1]] = 10
// [1,[4,[6]]] = 27
public static int ComputeNestedListSum(List <NestedInteger> list)
{
if (list == null)
{
throw new ArgumentNullException(nameof(list));
}
else if (list.Count == 0)
{
return(0);
}
int depth = 1, sum = 0;
Queue <NestedInteger> nestedIntegers = new Queue <NestedInteger>();
foreach (var ni in list)
{
nestedIntegers.Enqueue(ni);
}
while (nestedIntegers.Count > 0)
{
int size = nestedIntegers.Count;
for (int index = 0; index < size; index++)
{
NestedInteger nestedInteger = nestedIntegers.Dequeue();
if (nestedInteger.List != null)
{
foreach (var ni in nestedInteger.List)
{
nestedIntegers.Enqueue(ni);
}
}
else
{
sum += nestedInteger.Number * depth;
}
}
depth++;
}
return(sum);
}
private List <int> Parse(NestedInteger nested)
{
var values = new List <int>();
if (nested.IsInteger())
{
values.Add(nested.GetInteger());
}
if (nested.GetList() != null)
{
var listItems = nested.GetList().SelectMany(Parse);
values.AddRange(listItems);
}
return(values);
}
private int SumNestedInteger(NestedInteger ni, int depth)
{
if (ni.IsInteger())
{
return(ni.GetInteger().Value *depth);
}
else
{
var sum = 0;
foreach (var item in ni.GetList())
{
sum += SumNestedInteger(item, depth + 1);
}
return(sum);
}
}
public NestedInteger DeserializeImpl()
{
var ni = new NestedInteger();
int num = 0;
bool isNegative = false;
while (index < charArray.Length - 1)
{
index++;
var c = charArray[index];
if (c == '[')
{
ni.Add(DeserializeImpl());
}
else if (c == ']')
{
return(ni);
}
else if (c == ',')
{
continue;
}
else if (c == '-')
{
isNegative = true;
}
else
{
num = 10 * num + (c - '0');
if (!char.IsDigit(charArray[index + 1]))
{
if (isNegative)
{
num = -num;
}
ni.Add(new NestedInteger(num));
num = 0;
isNegative = false;
}
}
}
return(null);
}
private int GetSum(NestedInteger nestedInteger, int level)
{
int result = 0;
if (nestedInteger.IsInteger())
{
return(nestedInteger.GetInteger() * level);
}
else
{
foreach (var item in nestedInteger.GetList())
{
result += GetSum(item, level + 1);
}
}
return(result);
}
public bool HasNext()
{
while (stack.Count > 0)
{
NestedInteger t = stack.Peek();
if (t.IsInteger())
{
return(true);
}
stack.Pop();
list = t.GetList();
for (int i = list.Count - 1; i >= 0; --i)
{
stack.Push(list[i]);
}
}
return(false);
}
public void TestMethod2()
{
List <NestedInteger> list = new List <NestedInteger>();
NestedInteger ni = new NestedInteger(1);
list.Add(ni);
ni = new NestedInteger();
ni.Add(new NestedInteger(4));
var ni2 = new NestedInteger();
ni2.Add(new NestedInteger(6));
ni.Add(ni2);
list.Add(ni);
Solution s = new Solution();
var result = s.DepthSumInverse(list);
Assert.AreEqual(result, 17);
}
private int GetSum(NestedInteger nestedList, int weight)
{
int sum = 0;
if (nestedList.IsInteger())
{
sum += nestedList.GetInteger() * weight;
}
else
{
foreach (var item in nestedList.GetList())
{
sum += GetSum(item, weight + 1);
}
}
return(sum);
}
